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 <QTextCursor>
85 // a style sheet for buttons
86 // this is for example used for the background color setting button
87 static inline QString colorButtonStyleSheet(QColor const & bgColor)
89 if (bgColor.isValid()) {
90 QString rc = QLatin1String("background-color:");
99 using namespace lyx::support;
104 char const * const tex_graphics[] =
106 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
107 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
108 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
109 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
114 char const * const tex_graphics_gui[] =
116 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
117 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
118 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
119 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
120 "XeTeX", N_("None"), ""
124 char const * backref_opts[] =
126 "false", "section", "slide", "page", ""
130 char const * backref_opts_gui[] =
132 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
136 vector<string> engine_types_;
137 vector<pair<string, QString> > pagestyles;
139 QMap<QString, QString> rmfonts_;
140 QMap<QString, QString> sffonts_;
141 QMap<QString, QString> ttfonts_;
142 QMap<QString, QString> mathfonts_;
145 } // anonymous namespace
149 RGBColor set_backgroundcolor;
150 bool is_backgroundcolor;
151 RGBColor set_fontcolor;
153 RGBColor set_notefontcolor;
154 RGBColor set_boxbgcolor;
155 bool forced_fontspec_activation;
158 // used when sorting the textclass list.
159 class less_textclass_avail_desc
160 : public binary_function<string, string, int>
163 bool operator()(string const & lhs, string const & rhs) const
165 // Ordering criteria:
166 // 1. Availability of text class
167 // 2. Description (lexicographic)
168 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
169 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
170 int const order = compare_no_case(
171 translateIfPossible(from_utf8(tc1.description())),
172 translateIfPossible(from_utf8(tc2.description())));
173 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
174 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
183 vector<string> getRequiredList(string const & modName)
185 LyXModule const * const mod = theModuleList[modName];
187 return vector<string>(); //empty such thing
188 return mod->getRequiredModules();
192 vector<string> getExcludedList(string const & modName)
194 LyXModule const * const mod = theModuleList[modName];
196 return vector<string>(); //empty such thing
197 return mod->getExcludedModules();
201 docstring getModuleCategory(string const & modName)
203 LyXModule const * const mod = theModuleList[modName];
206 return from_utf8(mod->category());
210 docstring getModuleDescription(string const & modName)
212 LyXModule const * const mod = theModuleList[modName];
214 return _("Module not found!");
216 return translateIfPossible(from_utf8(mod->getDescription()));
220 vector<string> getPackageList(string const & modName)
222 LyXModule const * const mod = theModuleList[modName];
224 return vector<string>(); //empty such thing
225 return mod->getPackageList();
229 bool isModuleAvailable(string const & modName)
231 LyXModule const * const mod = theModuleList[modName];
234 return mod->isAvailable();
237 } // anonymous namespace
240 /////////////////////////////////////////////////////////////////////
242 // ModuleSelectionManager
244 /////////////////////////////////////////////////////////////////////
246 /// SelectionManager for use with modules
247 class ModuleSelectionManager : public GuiSelectionManager
251 ModuleSelectionManager(
252 QTreeView * availableLV,
253 QListView * selectedLV,
257 QPushButton * downPB,
258 GuiIdListModel * availableModel,
259 GuiIdListModel * selectedModel,
260 GuiDocument const * container)
261 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
262 upPB, downPB, availableModel, selectedModel), container_(container)
265 void updateProvidedModules(LayoutModuleList const & pm)
266 { provided_modules_ = pm.list(); }
268 void updateExcludedModules(LayoutModuleList const & em)
269 { excluded_modules_ = em.list(); }
272 virtual void updateAddPB();
274 virtual void updateUpPB();
276 virtual void updateDownPB();
278 virtual void updateDelPB();
279 /// returns availableModel as a GuiIdListModel
280 GuiIdListModel * getAvailableModel()
282 return dynamic_cast<GuiIdListModel *>(availableModel);
284 /// returns selectedModel as a GuiIdListModel
285 GuiIdListModel * getSelectedModel()
287 return dynamic_cast<GuiIdListModel *>(selectedModel);
289 /// keeps a list of the modules the text class provides
290 list<string> provided_modules_;
292 list<string> excluded_modules_;
294 GuiDocument const * container_;
297 void ModuleSelectionManager::updateAddPB()
299 int const arows = availableModel->rowCount();
300 QModelIndexList const avail_sels =
301 availableLV->selectionModel()->selectedIndexes();
303 // disable if there aren't any modules (?), if none of them is chosen
304 // in the dialog, or if the chosen one is already selected for use.
305 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
306 addPB->setEnabled(false);
310 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
311 string const modname = getAvailableModel()->getIDString(idx.row());
314 container_->params().layoutModuleCanBeAdded(modname);
315 addPB->setEnabled(enable);
319 void ModuleSelectionManager::updateDownPB()
321 int const srows = selectedModel->rowCount();
323 downPB->setEnabled(false);
326 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
327 int const curRow = curidx.row();
328 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
329 downPB->setEnabled(false);
333 // determine whether immediately succeding element requires this one
334 string const curmodname = getSelectedModel()->getIDString(curRow);
335 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
337 vector<string> reqs = getRequiredList(nextmodname);
339 // if it doesn't require anything....
341 downPB->setEnabled(true);
345 // Enable it if this module isn't required.
346 // FIXME This should perhaps be more flexible and check whether, even
347 // if the next one is required, there is also an earlier one that will do.
349 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
352 void ModuleSelectionManager::updateUpPB()
354 int const srows = selectedModel->rowCount();
356 upPB->setEnabled(false);
360 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
361 int curRow = curIdx.row();
362 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
363 upPB->setEnabled(false);
366 string const curmodname = getSelectedModel()->getIDString(curRow);
368 // determine whether immediately preceding element is required by this one
369 vector<string> reqs = getRequiredList(curmodname);
371 // if this one doesn't require anything....
373 upPB->setEnabled(true);
378 // Enable it if the preceding module isn't required.
379 // NOTE This is less flexible than it might be. We could check whether, even
380 // if the previous one is required, there is an earlier one that would do.
381 string const premod = getSelectedModel()->getIDString(curRow - 1);
382 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
385 void ModuleSelectionManager::updateDelPB()
387 int const srows = selectedModel->rowCount();
389 deletePB->setEnabled(false);
393 QModelIndex const & curidx =
394 selectedLV->selectionModel()->currentIndex();
395 int const curRow = curidx.row();
396 if (curRow < 0 || curRow >= srows) { // invalid index?
397 deletePB->setEnabled(false);
401 string const curmodname = getSelectedModel()->getIDString(curRow);
403 // We're looking here for a reason NOT to enable the button. If we
404 // find one, we disable it and return. If we don't, we'll end up at
405 // the end of the function, and then we enable it.
406 for (int i = curRow + 1; i < srows; ++i) {
407 string const thisMod = getSelectedModel()->getIDString(i);
408 vector<string> reqs = getRequiredList(thisMod);
409 //does this one require us?
410 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
414 // OK, so this module requires us
415 // is there an EARLIER module that also satisfies the require?
416 // NOTE We demand that it be earlier to keep the list of modules
417 // consistent with the rule that a module must be proceeded by a
418 // required module. There would be more flexible ways to proceed,
419 // but that would be a lot more complicated, and the logic here is
420 // already complicated. (That's why I've left the debugging code.)
421 // lyxerr << "Testing " << thisMod << endl;
422 bool foundone = false;
423 for (int j = 0; j < curRow; ++j) {
424 string const mod = getSelectedModel()->getIDString(j);
425 // lyxerr << "In loop: Testing " << mod << endl;
426 // do we satisfy the require?
427 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
428 // lyxerr << mod << " does the trick." << endl;
433 // did we find a module to satisfy the require?
435 // lyxerr << "No matching module found." << endl;
436 deletePB->setEnabled(false);
440 // lyxerr << "All's well that ends well." << endl;
441 deletePB->setEnabled(true);
445 /////////////////////////////////////////////////////////////////////
449 /////////////////////////////////////////////////////////////////////
451 PreambleModule::PreambleModule() : current_id_(0)
453 // This is not a memory leak. The object will be destroyed
455 (void) new LaTeXHighlighter(preambleTE->document());
456 preambleTE->setFont(guiApp->typewriterSystemFont());
457 preambleTE->setWordWrapMode(QTextOption::NoWrap);
458 setFocusProxy(preambleTE);
459 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
463 void PreambleModule::update(BufferParams const & params, BufferId id)
465 QString preamble = toqstr(params.preamble);
466 // Nothing to do if the params and preamble are unchanged.
467 if (id == current_id_
468 && preamble == preambleTE->document()->toPlainText())
471 QTextCursor cur = preambleTE->textCursor();
472 // Save the coords before switching to the new one.
473 preamble_coords_[current_id_] =
474 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
476 // Save the params address for further use.
478 preambleTE->document()->setPlainText(preamble);
479 Coords::const_iterator it = preamble_coords_.find(current_id_);
480 if (it == preamble_coords_.end())
481 // First time we open this one.
482 preamble_coords_[current_id_] = make_pair(0, 0);
484 // Restore saved coords.
485 QTextCursor cur = preambleTE->textCursor();
486 cur.setPosition(it->second.first);
487 preambleTE->setTextCursor(cur);
488 preambleTE->verticalScrollBar()->setValue(it->second.second);
493 void PreambleModule::apply(BufferParams & params)
495 params.preamble = fromqstr(preambleTE->document()->toPlainText());
499 void PreambleModule::closeEvent(QCloseEvent * e)
501 // Save the coords before closing.
502 QTextCursor cur = preambleTE->textCursor();
503 preamble_coords_[current_id_] =
504 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
509 /////////////////////////////////////////////////////////////////////
513 /////////////////////////////////////////////////////////////////////
516 LocalLayout::LocalLayout() : current_id_(0), validated_(false)
518 connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
519 connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
520 connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
524 void LocalLayout::update(BufferParams const & params, BufferId id)
526 QString layout = toqstr(params.getLocalLayout(false));
527 // Nothing to do if the params and preamble are unchanged.
528 if (id == current_id_
529 && layout == locallayoutTE->document()->toPlainText())
532 // Save the params address for further use.
534 locallayoutTE->document()->setPlainText(layout);
539 void LocalLayout::apply(BufferParams & params)
541 string const layout = fromqstr(locallayoutTE->document()->toPlainText());
542 params.setLocalLayout(layout, false);
546 void LocalLayout::textChanged()
548 static const QString message =
549 qt_("Press button to check validity...");
550 string const layout =
551 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
553 if (layout.empty()) {
555 validatePB->setEnabled(false);
556 validLB->setText("");
560 } else if (!validatePB->isEnabled()) {
561 // if that's already enabled, we shouldn't need to do anything.
563 validLB->setText(message);
564 validatePB->setEnabled(true);
565 convertPB->setEnabled(false);
571 void LocalLayout::convert() {
572 string const layout =
573 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
574 string const newlayout = TextClass::convert(layout);
576 if (newlayout.empty()) {
577 Alert::error(_("Conversion Failed!"),
578 _("Failed to convert local layout to current format."));
580 locallayoutTE->setPlainText(toqstr(newlayout));
586 void LocalLayout::convertPressed() {
592 void LocalLayout::validate() {
593 static const QString valid = qt_("Layout is valid!");
594 static const QString vtext =
595 toqstr("<p style=\"font-weight: bold; \">")
596 + valid + toqstr("</p>");
597 static const QString invalid = qt_("Layout is invalid!");
598 static const QString ivtext =
599 toqstr("<p style=\"color: #c00000; font-weight: bold; \">")
600 + invalid + toqstr("</p>");
602 string const layout =
603 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
604 if (!layout.empty()) {
605 TextClass::ReturnValues const ret = TextClass::validate(layout);
606 validated_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
607 validatePB->setEnabled(false);
608 validLB->setText(validated_ ? vtext : ivtext);
609 if (ret == TextClass::OK_OLDFORMAT) {
611 convertPB->setEnabled(true);
612 convertLB->setText(qt_("Convert to current format"));
622 void LocalLayout::validatePressed() {
628 /////////////////////////////////////////////////////////////////////
632 /////////////////////////////////////////////////////////////////////
635 GuiDocument::GuiDocument(GuiView & lv)
636 : GuiDialog(lv, "document", qt_("Document Settings")),
637 nonModuleChanged_(false)
641 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
642 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
643 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
644 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
646 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
647 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
649 // Manage the restore, ok, apply, restore and cancel/close buttons
650 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
652 bc().setApply(applyPB);
653 bc().setCancel(closePB);
654 bc().setRestore(restorePB);
658 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
659 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
660 this, SLOT(change_adaptor()));
661 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
662 this, SLOT(setLSpacing(int)));
663 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
664 this, SLOT(change_adaptor()));
666 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
667 this, SLOT(change_adaptor()));
668 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
669 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
670 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
671 this, SLOT(change_adaptor()));
672 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
673 this, SLOT(setIndent(int)));
674 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
675 this, SLOT(change_adaptor()));
676 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
677 this, SLOT(change_adaptor()));
679 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
680 this, SLOT(change_adaptor()));
681 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
682 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
683 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
684 this, SLOT(change_adaptor()));
685 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
686 this, SLOT(setSkip(int)));
687 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
688 this, SLOT(change_adaptor()));
689 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
690 this, SLOT(change_adaptor()));
692 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
693 this, SLOT(enableIndent(bool)));
694 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
695 this, SLOT(enableSkip(bool)));
697 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
698 this, SLOT(change_adaptor()));
699 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
700 this, SLOT(setColSep()));
701 connect(textLayoutModule->justCB, SIGNAL(clicked()),
702 this, SLOT(change_adaptor()));
704 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
705 textLayoutModule->lspacingLE));
706 textLayoutModule->indentLE->setValidator(new LengthValidator(
707 textLayoutModule->indentLE));
708 textLayoutModule->skipLE->setValidator(new LengthValidator(
709 textLayoutModule->skipLE));
711 textLayoutModule->indentCO->addItem(qt_("Default"));
712 textLayoutModule->indentCO->addItem(qt_("Custom"));
713 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
714 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
715 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
716 textLayoutModule->skipCO->addItem(qt_("Custom"));
717 textLayoutModule->lspacingCO->insertItem(
718 Spacing::Single, qt_("Single"));
719 textLayoutModule->lspacingCO->insertItem(
720 Spacing::Onehalf, qt_("OneHalf"));
721 textLayoutModule->lspacingCO->insertItem(
722 Spacing::Double, qt_("Double"));
723 textLayoutModule->lspacingCO->insertItem(
724 Spacing::Other, qt_("Custom"));
725 // initialize the length validator
726 bc().addCheckedLineEdit(textLayoutModule->indentLE);
727 bc().addCheckedLineEdit(textLayoutModule->skipLE);
730 // master/child handling
731 masterChildModule = new UiWidget<Ui::MasterChildUi>;
733 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
734 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
735 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
736 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
737 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
738 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
739 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
740 this, SLOT(change_adaptor()));
741 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
742 this, SLOT(change_adaptor()));
743 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
744 this, SLOT(change_adaptor()));
745 masterChildModule->childrenTW->setColumnCount(2);
746 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
747 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
748 masterChildModule->childrenTW->resizeColumnToContents(1);
749 masterChildModule->childrenTW->resizeColumnToContents(2);
753 outputModule = new UiWidget<Ui::OutputUi>;
755 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
756 this, SLOT(change_adaptor()));
757 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
758 this, SLOT(change_adaptor()));
759 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
760 this, SLOT(change_adaptor()));
761 connect(outputModule->cssCB, SIGNAL(stateChanged(int)),
762 this, SLOT(change_adaptor()));
763 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
764 this, SLOT(change_adaptor()));
766 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
767 this, SLOT(change_adaptor()));
768 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
769 this, SLOT(change_adaptor()));
770 outputModule->synccustomCB->addItem("");
771 outputModule->synccustomCB->addItem("\\synctex=1");
772 outputModule->synccustomCB->addItem("\\synctex=-1");
773 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
775 outputModule->synccustomCB->setValidator(new NoNewLineValidator(
776 outputModule->synccustomCB));
779 fontModule = new FontModule;
780 connect(fontModule->osFontsCB, SIGNAL(clicked()),
781 this, SLOT(change_adaptor()));
782 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
783 this, SLOT(osFontsChanged(bool)));
784 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
785 this, SLOT(change_adaptor()));
786 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
787 this, SLOT(romanChanged(int)));
788 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
789 this, SLOT(change_adaptor()));
790 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
791 this, SLOT(sansChanged(int)));
792 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
793 this, SLOT(change_adaptor()));
794 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
795 this, SLOT(ttChanged(int)));
796 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
797 this, SLOT(change_adaptor()));
798 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
799 this, SLOT(mathFontChanged(int)));
800 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
801 this, SLOT(change_adaptor()));
802 connect(fontModule->fontencCO, SIGNAL(activated(int)),
803 this, SLOT(change_adaptor()));
804 connect(fontModule->fontencCO, SIGNAL(activated(int)),
805 this, SLOT(fontencChanged(int)));
806 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
807 this, SLOT(change_adaptor()));
808 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
809 this, SLOT(change_adaptor()));
810 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
811 this, SLOT(change_adaptor()));
812 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
813 this, SLOT(change_adaptor()));
814 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
815 this, SLOT(change_adaptor()));
816 connect(fontModule->fontScCB, SIGNAL(clicked()),
817 this, SLOT(change_adaptor()));
818 connect(fontModule->fontScCB, SIGNAL(toggled(bool)),
819 this, SLOT(fontScToggled(bool)));
820 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
821 this, SLOT(change_adaptor()));
822 connect(fontModule->fontOsfCB, SIGNAL(toggled(bool)),
823 this, SLOT(fontOsfToggled(bool)));
825 fontModule->fontencLE->setValidator(new NoNewLineValidator(
826 fontModule->fontencLE));
827 fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
828 fontModule->cjkFontLE));
832 fontModule->fontsizeCO->addItem(qt_("Default"));
833 fontModule->fontsizeCO->addItem(qt_("10"));
834 fontModule->fontsizeCO->addItem(qt_("11"));
835 fontModule->fontsizeCO->addItem(qt_("12"));
837 fontModule->fontencCO->addItem(qt_("Default"), QString("global"));
838 fontModule->fontencCO->addItem(qt_("Custom"), QString("custom"));
839 fontModule->fontencCO->addItem(qt_("None (no fontenc)"), QString("default"));
841 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
842 fontModule->fontsDefaultCO->addItem(
843 qt_(GuiDocument::fontfamilies_gui[n]));
845 if (!LaTeXFeatures::isAvailable("fontspec"))
846 fontModule->osFontsCB->setToolTip(
847 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
848 "You need to install the package \"fontspec\" to use this feature"));
852 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
853 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
854 this, SLOT(papersizeChanged(int)));
855 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
856 this, SLOT(papersizeChanged(int)));
857 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
858 this, SLOT(change_adaptor()));
859 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
860 this, SLOT(change_adaptor()));
861 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
862 this, SLOT(change_adaptor()));
863 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
864 this, SLOT(change_adaptor()));
865 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
866 this, SLOT(change_adaptor()));
867 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
868 this, SLOT(change_adaptor()));
869 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
870 this, SLOT(change_adaptor()));
871 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
872 this, SLOT(change_adaptor()));
873 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
874 this, SLOT(change_adaptor()));
875 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
876 this, SLOT(change_adaptor()));
878 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
879 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
880 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
881 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
882 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
883 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
884 pageLayoutModule->paperheightL);
885 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
886 pageLayoutModule->paperwidthL);
888 QComboBox * cb = pageLayoutModule->papersizeCO;
889 cb->addItem(qt_("Default"));
890 cb->addItem(qt_("Custom"));
891 cb->addItem(qt_("US letter"));
892 cb->addItem(qt_("US legal"));
893 cb->addItem(qt_("US executive"));
894 cb->addItem(qt_("A0"));
895 cb->addItem(qt_("A1"));
896 cb->addItem(qt_("A2"));
897 cb->addItem(qt_("A3"));
898 cb->addItem(qt_("A4"));
899 cb->addItem(qt_("A5"));
900 cb->addItem(qt_("A6"));
901 cb->addItem(qt_("B0"));
902 cb->addItem(qt_("B1"));
903 cb->addItem(qt_("B2"));
904 cb->addItem(qt_("B3"));
905 cb->addItem(qt_("B4"));
906 cb->addItem(qt_("B5"));
907 cb->addItem(qt_("B6"));
908 cb->addItem(qt_("C0"));
909 cb->addItem(qt_("C1"));
910 cb->addItem(qt_("C2"));
911 cb->addItem(qt_("C3"));
912 cb->addItem(qt_("C4"));
913 cb->addItem(qt_("C5"));
914 cb->addItem(qt_("C6"));
915 cb->addItem(qt_("JIS B0"));
916 cb->addItem(qt_("JIS B1"));
917 cb->addItem(qt_("JIS B2"));
918 cb->addItem(qt_("JIS B3"));
919 cb->addItem(qt_("JIS B4"));
920 cb->addItem(qt_("JIS B5"));
921 cb->addItem(qt_("JIS B6"));
922 // remove the %-items from the unit choice
923 pageLayoutModule->paperwidthUnitCO->noPercents();
924 pageLayoutModule->paperheightUnitCO->noPercents();
925 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
926 pageLayoutModule->paperheightLE));
927 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
928 pageLayoutModule->paperwidthLE));
932 marginsModule = new UiWidget<Ui::MarginsUi>;
933 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
934 this, SLOT(setCustomMargins(bool)));
935 connect(marginsModule->marginCB, SIGNAL(clicked()),
936 this, SLOT(change_adaptor()));
937 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
938 this, SLOT(change_adaptor()));
939 connect(marginsModule->topUnit, SIGNAL(activated(int)),
940 this, SLOT(change_adaptor()));
941 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
942 this, SLOT(change_adaptor()));
943 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
944 this, SLOT(change_adaptor()));
945 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
946 this, SLOT(change_adaptor()));
947 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
948 this, SLOT(change_adaptor()));
949 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
950 this, SLOT(change_adaptor()));
951 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
952 this, SLOT(change_adaptor()));
953 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
954 this, SLOT(change_adaptor()));
955 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
956 this, SLOT(change_adaptor()));
957 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
958 this, SLOT(change_adaptor()));
959 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
960 this, SLOT(change_adaptor()));
961 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
962 this, SLOT(change_adaptor()));
963 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
964 this, SLOT(change_adaptor()));
965 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
966 this, SLOT(change_adaptor()));
967 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
968 this, SLOT(change_adaptor()));
969 marginsModule->topLE->setValidator(new LengthValidator(
970 marginsModule->topLE));
971 marginsModule->bottomLE->setValidator(new LengthValidator(
972 marginsModule->bottomLE));
973 marginsModule->innerLE->setValidator(new LengthValidator(
974 marginsModule->innerLE));
975 marginsModule->outerLE->setValidator(new LengthValidator(
976 marginsModule->outerLE));
977 marginsModule->headsepLE->setValidator(new LengthValidator(
978 marginsModule->headsepLE));
979 marginsModule->headheightLE->setValidator(new LengthValidator(
980 marginsModule->headheightLE));
981 marginsModule->footskipLE->setValidator(new LengthValidator(
982 marginsModule->footskipLE));
983 marginsModule->columnsepLE->setValidator(new LengthValidator(
984 marginsModule->columnsepLE));
986 bc().addCheckedLineEdit(marginsModule->topLE,
987 marginsModule->topL);
988 bc().addCheckedLineEdit(marginsModule->bottomLE,
989 marginsModule->bottomL);
990 bc().addCheckedLineEdit(marginsModule->innerLE,
991 marginsModule->innerL);
992 bc().addCheckedLineEdit(marginsModule->outerLE,
993 marginsModule->outerL);
994 bc().addCheckedLineEdit(marginsModule->headsepLE,
995 marginsModule->headsepL);
996 bc().addCheckedLineEdit(marginsModule->headheightLE,
997 marginsModule->headheightL);
998 bc().addCheckedLineEdit(marginsModule->footskipLE,
999 marginsModule->footskipL);
1000 bc().addCheckedLineEdit(marginsModule->columnsepLE,
1001 marginsModule->columnsepL);
1005 langModule = new UiWidget<Ui::LanguageUi>;
1006 connect(langModule->languageCO, SIGNAL(activated(int)),
1007 this, SLOT(change_adaptor()));
1008 connect(langModule->languageCO, SIGNAL(activated(int)),
1009 this, SLOT(languageChanged(int)));
1010 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1011 this, SLOT(change_adaptor()));
1012 connect(langModule->otherencodingRB, SIGNAL(clicked()),
1013 this, SLOT(change_adaptor()));
1014 connect(langModule->encodingCO, SIGNAL(activated(int)),
1015 this, SLOT(change_adaptor()));
1016 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1017 this, SLOT(change_adaptor()));
1018 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1019 this, SLOT(change_adaptor()));
1020 connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1021 this, SLOT(change_adaptor()));
1022 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1023 this, SLOT(languagePackageChanged(int)));
1025 langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1026 langModule->languagePackageLE));
1028 QAbstractItemModel * language_model = guiApp->languageModel();
1029 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1030 language_model->sort(0);
1031 langModule->languageCO->setModel(language_model);
1032 langModule->languageCO->setModelColumn(0);
1034 // Always put the default encoding in the first position.
1035 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1036 QStringList encodinglist;
1037 Encodings::const_iterator it = encodings.begin();
1038 Encodings::const_iterator const end = encodings.end();
1039 for (; it != end; ++it)
1041 encodinglist.append(qt_(it->guiName()));
1042 encodinglist.sort();
1043 langModule->encodingCO->addItems(encodinglist);
1045 langModule->quoteStyleCO->addItem(
1046 qt_("``text''"),InsetQuotes::EnglishQuotes);
1047 langModule->quoteStyleCO->addItem(
1048 qt_("''text''"), InsetQuotes::SwedishQuotes);
1049 langModule->quoteStyleCO->addItem
1050 (qt_(",,text``"), InsetQuotes::GermanQuotes);
1051 langModule->quoteStyleCO->addItem(
1052 qt_(",,text''"), InsetQuotes::PolishQuotes);
1053 langModule->quoteStyleCO->addItem(
1054 qt_("<<text>>"), InsetQuotes::FrenchQuotes);
1055 langModule->quoteStyleCO->addItem(
1056 qt_(">>text<<"), InsetQuotes::DanishQuotes);
1058 langModule->languagePackageCO->addItem(
1059 qt_("Default"), toqstr("default"));
1060 langModule->languagePackageCO->addItem(
1061 qt_("Automatic"), toqstr("auto"));
1062 langModule->languagePackageCO->addItem(
1063 qt_("Always Babel"), toqstr("babel"));
1064 langModule->languagePackageCO->addItem(
1065 qt_("Custom"), toqstr("custom"));
1066 langModule->languagePackageCO->addItem(
1067 qt_("None[[language package]]"), toqstr("none"));
1071 colorModule = new UiWidget<Ui::ColorUi>;
1072 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1073 this, SLOT(changeFontColor()));
1074 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1075 this, SLOT(deleteFontColor()));
1076 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1077 this, SLOT(changeNoteFontColor()));
1078 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1079 this, SLOT(deleteNoteFontColor()));
1080 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1081 this, SLOT(changeBackgroundColor()));
1082 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1083 this, SLOT(deleteBackgroundColor()));
1084 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1085 this, SLOT(changeBoxBackgroundColor()));
1086 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1087 this, SLOT(deleteBoxBackgroundColor()));
1091 numberingModule = new UiWidget<Ui::NumberingUi>;
1092 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1093 this, SLOT(change_adaptor()));
1094 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1095 this, SLOT(change_adaptor()));
1096 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1097 this, SLOT(updateNumbering()));
1098 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1099 this, SLOT(updateNumbering()));
1100 numberingModule->tocTW->setColumnCount(3);
1101 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1102 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1103 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1104 setSectionResizeMode(numberingModule->tocTW->header(), QHeaderView::ResizeToContents);
1107 biblioModule = new UiWidget<Ui::BiblioUi>;
1108 connect(biblioModule->citeDefaultRB, SIGNAL(toggled(bool)),
1109 this, SLOT(setNumerical(bool)));
1110 connect(biblioModule->citeJurabibRB, SIGNAL(toggled(bool)),
1111 this, SLOT(setAuthorYear(bool)));
1112 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1113 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1114 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1115 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1116 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1117 this, SLOT(biblioChanged()));
1118 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1119 this, SLOT(biblioChanged()));
1120 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1121 this, SLOT(biblioChanged()));
1122 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1123 this, SLOT(biblioChanged()));
1124 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1125 this, SLOT(biblioChanged()));
1126 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1127 this, SLOT(bibtexChanged(int)));
1128 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1129 this, SLOT(biblioChanged()));
1130 connect(biblioModule->bibtexStyleLE, SIGNAL(textChanged(QString)),
1131 this, SLOT(biblioChanged()));
1133 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1134 biblioModule->bibtexOptionsLE));
1135 biblioModule->bibtexStyleLE->setValidator(new NoNewLineValidator(
1136 biblioModule->bibtexStyleLE));
1138 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1139 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1140 biblioModule->citeStyleCO->setCurrentIndex(0);
1142 // NOTE: we do not provide "custom" here for security reasons!
1143 biblioModule->bibtexCO->clear();
1144 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1145 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1146 it != lyxrc.bibtex_alternatives.end(); ++it) {
1147 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1148 biblioModule->bibtexCO->addItem(command, command);
1153 indicesModule = new GuiIndices;
1154 connect(indicesModule, SIGNAL(changed()),
1155 this, SLOT(change_adaptor()));
1159 mathsModule = new UiWidget<Ui::MathsUi>;
1160 QStringList headers;
1161 headers << qt_("Package") << qt_("Load automatically")
1162 << qt_("Load always") << qt_("Do not load");
1163 mathsModule->packagesTW->setHorizontalHeaderLabels(headers);
1164 setSectionResizeMode(mathsModule->packagesTW->horizontalHeader(), QHeaderView::Stretch);
1165 map<string, string> const & packages = BufferParams::auto_packages();
1166 mathsModule->packagesTW->setRowCount(packages.size());
1168 for (map<string, string>::const_iterator it = packages.begin();
1169 it != packages.end(); ++it) {
1170 docstring const package = from_ascii(it->first);
1171 QString autoTooltip = qt_(it->second);
1172 QString alwaysTooltip;
1173 if (package == "amsmath")
1175 qt_("The AMS LaTeX packages are always used");
1177 alwaysTooltip = toqstr(bformat(
1178 _("The LaTeX package %1$s is always used"),
1180 QString neverTooltip;
1181 if (package == "amsmath")
1183 qt_("The AMS LaTeX packages are never used");
1185 neverTooltip = toqstr(bformat(
1186 _("The LaTeX package %1$s is never used"),
1188 QRadioButton * autoRB = new QRadioButton(mathsModule);
1189 QRadioButton * alwaysRB = new QRadioButton(mathsModule);
1190 QRadioButton * neverRB = new QRadioButton(mathsModule);
1191 QButtonGroup * packageGroup = new QButtonGroup(mathsModule);
1192 packageGroup->addButton(autoRB);
1193 packageGroup->addButton(alwaysRB);
1194 packageGroup->addButton(neverRB);
1195 autoRB->setToolTip(autoTooltip);
1196 alwaysRB->setToolTip(alwaysTooltip);
1197 neverRB->setToolTip(neverTooltip);
1198 QTableWidgetItem * pack = new QTableWidgetItem(toqstr(package));
1199 mathsModule->packagesTW->setItem(i, 0, pack);
1200 mathsModule->packagesTW->setCellWidget(i, 1, autoRB);
1201 mathsModule->packagesTW->setCellWidget(i, 2, alwaysRB);
1202 mathsModule->packagesTW->setCellWidget(i, 3, neverRB);
1204 connect(autoRB, SIGNAL(clicked()),
1205 this, SLOT(change_adaptor()));
1206 connect(alwaysRB, SIGNAL(clicked()),
1207 this, SLOT(change_adaptor()));
1208 connect(neverRB, SIGNAL(clicked()),
1209 this, SLOT(change_adaptor()));
1212 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1213 this, SLOT(allPackagesAuto()));
1214 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1215 this, SLOT(allPackagesAlways()));
1216 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1217 this, SLOT(allPackagesNot()));
1218 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1219 this, SLOT(change_adaptor()));
1220 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1221 this, SLOT(change_adaptor()));
1222 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1223 this, SLOT(change_adaptor()));
1227 latexModule = new UiWidget<Ui::LaTeXUi>;
1228 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1229 this, SLOT(change_adaptor()));
1230 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1231 this, SLOT(change_adaptor()));
1232 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1233 this, SLOT(change_adaptor()));
1234 connect(latexModule->classCO, SIGNAL(activated(int)),
1235 this, SLOT(classChanged_adaptor()));
1236 connect(latexModule->classCO, SIGNAL(activated(int)),
1237 this, SLOT(change_adaptor()));
1238 connect(latexModule->layoutPB, SIGNAL(clicked()),
1239 this, SLOT(browseLayout()));
1240 connect(latexModule->layoutPB, SIGNAL(clicked()),
1241 this, SLOT(change_adaptor()));
1242 connect(latexModule->childDocGB, SIGNAL(clicked()),
1243 this, SLOT(change_adaptor()));
1244 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1245 this, SLOT(change_adaptor()));
1246 connect(latexModule->childDocPB, SIGNAL(clicked()),
1247 this, SLOT(browseMaster()));
1248 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1249 this, SLOT(change_adaptor()));
1250 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1251 this, SLOT(change_adaptor()));
1253 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1254 latexModule->optionsLE));
1255 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1256 latexModule->childDocLE));
1258 // postscript drivers
1259 for (int n = 0; tex_graphics[n][0]; ++n) {
1260 QString enc = qt_(tex_graphics_gui[n]);
1261 latexModule->psdriverCO->addItem(enc);
1264 LayoutFileList const & bcl = LayoutFileList::get();
1265 vector<LayoutFileIndex> classList = bcl.classList();
1266 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1268 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1269 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1270 for (int i = 0; cit != cen; ++cit, ++i) {
1271 LayoutFile const & tc = bcl[*cit];
1272 bool const available = tc.isTeXClassAvailable();
1273 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1274 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1275 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1277 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1278 tooltip += '\n' + toqstr(wrap(bformat(_("Class not found by LyX. "
1279 "Please check if you have the matching %1$s class "
1280 "and all required packages (%2$s) installed."),
1281 output_type, from_utf8(tc.prerequisites(", ")))));
1283 latexModule->classCO->addItemSort(toqstr(tc.name()),
1285 toqstr(translateIfPossible(from_utf8(tc.category()))),
1287 true, true, true, available);
1292 branchesModule = new GuiBranches;
1293 connect(branchesModule, SIGNAL(changed()),
1294 this, SLOT(change_adaptor()));
1295 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1296 this, SLOT(branchesRename(docstring const &, docstring const &)));
1297 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1298 updateUnknownBranches();
1302 preambleModule = new PreambleModule;
1303 connect(preambleModule, SIGNAL(changed()),
1304 this, SLOT(change_adaptor()));
1306 localLayout = new LocalLayout;
1307 connect(localLayout, SIGNAL(changed()),
1308 this, SLOT(change_adaptor()));
1312 bulletsModule = new BulletsModule;
1313 connect(bulletsModule, SIGNAL(changed()),
1314 this, SLOT(change_adaptor()));
1318 modulesModule = new UiWidget<Ui::ModulesUi>;
1319 modulesModule->availableLV->header()->setVisible(false);
1320 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1321 modulesModule->availableLV->header()->setStretchLastSection(false);
1323 new ModuleSelectionManager(modulesModule->availableLV,
1324 modulesModule->selectedLV,
1325 modulesModule->addPB, modulesModule->deletePB,
1326 modulesModule->upPB, modulesModule->downPB,
1327 availableModel(), selectedModel(), this);
1328 connect(selectionManager, SIGNAL(updateHook()),
1329 this, SLOT(updateModuleInfo()));
1330 connect(selectionManager, SIGNAL(selectionChanged()),
1331 this, SLOT(modulesChanged()));
1335 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1336 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1337 this, SLOT(change_adaptor()));
1338 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1339 this, SLOT(change_adaptor()));
1340 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1341 this, SLOT(change_adaptor()));
1342 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1343 this, SLOT(change_adaptor()));
1344 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1345 this, SLOT(change_adaptor()));
1346 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1347 this, SLOT(change_adaptor()));
1348 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1349 this, SLOT(change_adaptor()));
1350 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1351 this, SLOT(change_adaptor()));
1352 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1353 this, SLOT(change_adaptor()));
1354 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1355 this, SLOT(change_adaptor()));
1356 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1357 this, SLOT(change_adaptor()));
1358 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1359 this, SLOT(change_adaptor()));
1360 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1361 this, SLOT(change_adaptor()));
1362 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1363 this, SLOT(change_adaptor()));
1364 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1365 this, SLOT(change_adaptor()));
1366 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1367 this, SLOT(change_adaptor()));
1369 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1370 pdfSupportModule->titleLE));
1371 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1372 pdfSupportModule->authorLE));
1373 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1374 pdfSupportModule->subjectLE));
1375 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1376 pdfSupportModule->keywordsLE));
1377 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1378 pdfSupportModule->optionsLE));
1380 for (int i = 0; backref_opts[i][0]; ++i)
1381 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1385 floatModule = new FloatPlacement;
1386 connect(floatModule, SIGNAL(changed()),
1387 this, SLOT(change_adaptor()));
1391 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1392 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1393 this, SLOT(change_adaptor()));
1394 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1395 this, SLOT(change_adaptor()));
1396 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1397 this, SLOT(setListingsMessage()));
1398 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1399 this, SLOT(setListingsMessage()));
1400 listingsModule->listingsTB->setPlainText(
1401 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1405 docPS->addPanel(latexModule, N_("Document Class"));
1406 docPS->addPanel(masterChildModule, N_("Child Documents"));
1407 docPS->addPanel(modulesModule, N_("Modules"));
1408 docPS->addPanel(localLayout, N_("Local Layout"));
1409 docPS->addPanel(fontModule, N_("Fonts"));
1410 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1411 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1412 docPS->addPanel(marginsModule, N_("Page Margins"));
1413 docPS->addPanel(langModule, N_("Language"));
1414 docPS->addPanel(colorModule, N_("Colors"));
1415 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1416 docPS->addPanel(biblioModule, N_("Bibliography"));
1417 docPS->addPanel(indicesModule, N_("Indexes"));
1418 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1419 docPS->addPanel(mathsModule, N_("Math Options"));
1420 docPS->addPanel(floatModule, N_("Float Placement"));
1421 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1422 docPS->addPanel(bulletsModule, N_("Bullets"));
1423 docPS->addPanel(branchesModule, N_("Branches"));
1424 docPS->addPanel(outputModule, N_("Output"));
1425 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1426 docPS->setCurrentPanel("Document Class");
1427 // FIXME: hack to work around resizing bug in Qt >= 4.2
1428 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1429 #if QT_VERSION >= 0x040200
1430 docPS->updateGeometry();
1435 void GuiDocument::saveDefaultClicked()
1441 void GuiDocument::useDefaultsClicked()
1447 void GuiDocument::change_adaptor()
1449 nonModuleChanged_ = true;
1454 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1459 string child = fromqstr(item->text(0));
1463 if (std::find(includeonlys_.begin(),
1464 includeonlys_.end(), child) != includeonlys_.end())
1465 includeonlys_.remove(child);
1467 includeonlys_.push_back(child);
1469 updateIncludeonlys();
1474 QString GuiDocument::validateListingsParameters()
1476 // use a cache here to avoid repeated validation
1477 // of the same parameters
1479 static string param_cache;
1480 static QString msg_cache;
1482 if (listingsModule->bypassCB->isChecked())
1485 string params = fromqstr(listingsModule->listingsED->toPlainText());
1486 if (params != param_cache) {
1487 param_cache = params;
1488 msg_cache = toqstr(InsetListingsParams(params).validate());
1494 void GuiDocument::setListingsMessage()
1497 static bool isOK = true;
1498 QString msg = validateListingsParameters();
1499 if (msg.isEmpty()) {
1503 // listingsTB->setTextColor("black");
1504 listingsModule->listingsTB->setPlainText(
1505 qt_("Input listings parameters below. "
1506 "Enter ? for a list of parameters."));
1509 // listingsTB->setTextColor("red");
1510 listingsModule->listingsTB->setPlainText(msg);
1515 void GuiDocument::setLSpacing(int item)
1517 textLayoutModule->lspacingLE->setEnabled(item == 3);
1521 void GuiDocument::setIndent(int item)
1523 bool const enable = (item == 1);
1524 textLayoutModule->indentLE->setEnabled(enable);
1525 textLayoutModule->indentLengthCO->setEnabled(enable);
1526 textLayoutModule->skipLE->setEnabled(false);
1527 textLayoutModule->skipLengthCO->setEnabled(false);
1532 void GuiDocument::enableIndent(bool indent)
1534 textLayoutModule->skipLE->setEnabled(!indent);
1535 textLayoutModule->skipLengthCO->setEnabled(!indent);
1537 setIndent(textLayoutModule->indentCO->currentIndex());
1541 void GuiDocument::setSkip(int item)
1543 bool const enable = (item == 3);
1544 textLayoutModule->skipLE->setEnabled(enable);
1545 textLayoutModule->skipLengthCO->setEnabled(enable);
1550 void GuiDocument::enableSkip(bool skip)
1552 textLayoutModule->indentLE->setEnabled(!skip);
1553 textLayoutModule->indentLengthCO->setEnabled(!skip);
1555 setSkip(textLayoutModule->skipCO->currentIndex());
1559 void GuiDocument::setMargins()
1561 bool const extern_geometry =
1562 documentClass().provides("geometry");
1563 marginsModule->marginCB->setEnabled(!extern_geometry);
1564 if (extern_geometry) {
1565 marginsModule->marginCB->setChecked(false);
1566 setCustomMargins(true);
1568 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1569 setCustomMargins(!bp_.use_geometry);
1574 void GuiDocument::papersizeChanged(int paper_size)
1576 setCustomPapersize(paper_size == 1);
1580 void GuiDocument::setCustomPapersize(bool custom)
1582 pageLayoutModule->paperwidthL->setEnabled(custom);
1583 pageLayoutModule->paperwidthLE->setEnabled(custom);
1584 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1585 pageLayoutModule->paperheightL->setEnabled(custom);
1586 pageLayoutModule->paperheightLE->setEnabled(custom);
1587 pageLayoutModule->paperheightLE->setFocus();
1588 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1592 void GuiDocument::setColSep()
1594 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1598 void GuiDocument::setCustomMargins(bool custom)
1600 marginsModule->topL->setEnabled(!custom);
1601 marginsModule->topLE->setEnabled(!custom);
1602 marginsModule->topUnit->setEnabled(!custom);
1604 marginsModule->bottomL->setEnabled(!custom);
1605 marginsModule->bottomLE->setEnabled(!custom);
1606 marginsModule->bottomUnit->setEnabled(!custom);
1608 marginsModule->innerL->setEnabled(!custom);
1609 marginsModule->innerLE->setEnabled(!custom);
1610 marginsModule->innerUnit->setEnabled(!custom);
1612 marginsModule->outerL->setEnabled(!custom);
1613 marginsModule->outerLE->setEnabled(!custom);
1614 marginsModule->outerUnit->setEnabled(!custom);
1616 marginsModule->headheightL->setEnabled(!custom);
1617 marginsModule->headheightLE->setEnabled(!custom);
1618 marginsModule->headheightUnit->setEnabled(!custom);
1620 marginsModule->headsepL->setEnabled(!custom);
1621 marginsModule->headsepLE->setEnabled(!custom);
1622 marginsModule->headsepUnit->setEnabled(!custom);
1624 marginsModule->footskipL->setEnabled(!custom);
1625 marginsModule->footskipLE->setEnabled(!custom);
1626 marginsModule->footskipUnit->setEnabled(!custom);
1628 bool const enableColSep = !custom &&
1629 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1630 marginsModule->columnsepL->setEnabled(enableColSep);
1631 marginsModule->columnsepLE->setEnabled(enableColSep);
1632 marginsModule->columnsepUnit->setEnabled(enableColSep);
1636 void GuiDocument::changeBackgroundColor()
1638 QColor const & newColor = QColorDialog::getColor(
1639 rgb2qcolor(set_backgroundcolor), asQWidget());
1640 if (!newColor.isValid())
1642 // set the button color and text
1643 colorModule->backgroundPB->setStyleSheet(
1644 colorButtonStyleSheet(newColor));
1645 colorModule->backgroundPB->setText(qt_("&Change..."));
1647 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1648 is_backgroundcolor = true;
1653 void GuiDocument::deleteBackgroundColor()
1655 // set the button color back to default by setting an empty StyleSheet
1656 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1657 // change button text
1658 colorModule->backgroundPB->setText(qt_("&Default..."));
1659 // save default color (white)
1660 set_backgroundcolor = rgbFromHexName("#ffffff");
1661 is_backgroundcolor = false;
1666 void GuiDocument::changeFontColor()
1668 QColor const & newColor = QColorDialog::getColor(
1669 rgb2qcolor(set_fontcolor), asQWidget());
1670 if (!newColor.isValid())
1672 // set the button color and text
1673 colorModule->fontColorPB->setStyleSheet(
1674 colorButtonStyleSheet(newColor));
1675 colorModule->fontColorPB->setText(qt_("&Change..."));
1677 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1678 is_fontcolor = true;
1683 void GuiDocument::deleteFontColor()
1685 // set the button color back to default by setting an empty StyleSheet
1686 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1687 // change button text
1688 colorModule->fontColorPB->setText(qt_("&Default..."));
1689 // save default color (black)
1690 set_fontcolor = rgbFromHexName("#000000");
1691 is_fontcolor = false;
1696 void GuiDocument::changeNoteFontColor()
1698 QColor const & newColor = QColorDialog::getColor(
1699 rgb2qcolor(set_notefontcolor), asQWidget());
1700 if (!newColor.isValid())
1702 // set the button color
1703 colorModule->noteFontColorPB->setStyleSheet(
1704 colorButtonStyleSheet(newColor));
1706 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1711 void GuiDocument::deleteNoteFontColor()
1713 // set the button color back to pref
1714 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1715 colorModule->noteFontColorPB->setStyleSheet(
1716 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1721 void GuiDocument::changeBoxBackgroundColor()
1723 QColor const & newColor = QColorDialog::getColor(
1724 rgb2qcolor(set_boxbgcolor), asQWidget());
1725 if (!newColor.isValid())
1727 // set the button color
1728 colorModule->boxBackgroundPB->setStyleSheet(
1729 colorButtonStyleSheet(newColor));
1731 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1736 void GuiDocument::deleteBoxBackgroundColor()
1738 // set the button color back to pref
1739 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1740 colorModule->boxBackgroundPB->setStyleSheet(
1741 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1746 void GuiDocument::languageChanged(int i)
1748 // some languages only work with polyglossia/XeTeX
1749 Language const * lang = lyx::languages.getLanguage(
1750 fromqstr(langModule->languageCO->itemData(i).toString()));
1751 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1752 // If we force to switch fontspec on, store
1753 // current state (#8717)
1754 if (fontModule->osFontsCB->isEnabled())
1755 forced_fontspec_activation =
1756 !fontModule->osFontsCB->isChecked();
1757 fontModule->osFontsCB->setChecked(true);
1758 fontModule->osFontsCB->setEnabled(false);
1761 fontModule->osFontsCB->setEnabled(true);
1762 // If we have forced to switch fontspec on,
1763 // restore previous state (#8717)
1764 if (forced_fontspec_activation)
1765 fontModule->osFontsCB->setChecked(false);
1766 forced_fontspec_activation = false;
1769 // set appropriate quotation mark style
1770 if (!lang->quoteStyle().empty()) {
1771 langModule->quoteStyleCO->setCurrentIndex(
1772 bp_.getQuoteStyle(lang->quoteStyle()));
1777 void GuiDocument::osFontsChanged(bool nontexfonts)
1779 bool const tex_fonts = !nontexfonts;
1780 // store current fonts
1781 QString const font_roman = fontModule->fontsRomanCO->itemData(
1782 fontModule->fontsRomanCO->currentIndex()).toString();
1783 QString const font_sans = fontModule->fontsSansCO->itemData(
1784 fontModule->fontsSansCO->currentIndex()).toString();
1785 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1786 fontModule->fontsTypewriterCO->currentIndex()).toString();
1787 QString const font_math = fontModule->fontsMathCO->itemData(
1788 fontModule->fontsMathCO->currentIndex()).toString();
1789 int const font_sf_scale = fontModule->scaleSansSB->value();
1790 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1793 // store default format
1794 QString const dformat = outputModule->defaultFormatCO->itemData(
1795 outputModule->defaultFormatCO->currentIndex()).toString();
1796 updateDefaultFormat();
1797 // try to restore default format
1798 int index = outputModule->defaultFormatCO->findData(dformat);
1799 // set to default if format is not found
1802 outputModule->defaultFormatCO->setCurrentIndex(index);
1804 // try to restore fonts which were selected two toggles ago
1805 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1807 fontModule->fontsRomanCO->setCurrentIndex(index);
1808 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1810 fontModule->fontsSansCO->setCurrentIndex(index);
1811 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1813 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1814 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1816 fontModule->fontsMathCO->setCurrentIndex(index);
1817 // save fonts for next next toggle
1818 fontModule->font_roman = font_roman;
1819 fontModule->font_sans = font_sans;
1820 fontModule->font_typewriter = font_typewriter;
1821 fontModule->font_math = font_math;
1822 fontModule->font_sf_scale = font_sf_scale;
1823 fontModule->font_tt_scale = font_tt_scale;
1825 langModule->encodingCO->setEnabled(tex_fonts &&
1826 !langModule->defaultencodingRB->isChecked());
1827 langModule->defaultencodingRB->setEnabled(tex_fonts);
1828 langModule->otherencodingRB->setEnabled(tex_fonts);
1830 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1831 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1832 fontModule->cjkFontLE->setEnabled(tex_fonts);
1833 fontModule->cjkFontLA->setEnabled(tex_fonts);
1835 updateFontOptions();
1837 fontModule->fontencLA->setEnabled(tex_fonts);
1838 fontModule->fontencCO->setEnabled(tex_fonts);
1840 fontModule->fontencLE->setEnabled(false);
1842 fontencChanged(fontModule->fontencCO->currentIndex());
1846 void GuiDocument::mathFontChanged(int)
1848 updateFontOptions();
1852 void GuiDocument::fontOsfToggled(bool state)
1854 if (fontModule->osFontsCB->isChecked())
1856 QString font = fontModule->fontsRomanCO->itemData(
1857 fontModule->fontsRomanCO->currentIndex()).toString();
1858 if (hasMonolithicExpertSet(font))
1859 fontModule->fontScCB->setChecked(state);
1863 void GuiDocument::fontScToggled(bool state)
1865 if (fontModule->osFontsCB->isChecked())
1867 QString font = fontModule->fontsRomanCO->itemData(
1868 fontModule->fontsRomanCO->currentIndex()).toString();
1869 if (hasMonolithicExpertSet(font))
1870 fontModule->fontOsfCB->setChecked(state);
1874 void GuiDocument::updateFontOptions()
1876 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1879 font = fontModule->fontsSansCO->itemData(
1880 fontModule->fontsSansCO->currentIndex()).toString();
1881 bool scaleable = providesScale(font);
1882 fontModule->scaleSansSB->setEnabled(scaleable);
1883 fontModule->scaleSansLA->setEnabled(scaleable);
1885 font = fontModule->fontsTypewriterCO->itemData(
1886 fontModule->fontsTypewriterCO->currentIndex()).toString();
1887 scaleable = providesScale(font);
1888 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1889 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1891 font = fontModule->fontsRomanCO->itemData(
1892 fontModule->fontsRomanCO->currentIndex()).toString();
1893 fontModule->fontScCB->setEnabled(providesSC(font));
1894 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1895 updateMathFonts(font);
1899 void GuiDocument::updateFontsize(string const & items, string const & sel)
1901 fontModule->fontsizeCO->clear();
1902 fontModule->fontsizeCO->addItem(qt_("Default"));
1904 for (int n = 0; !token(items,'|',n).empty(); ++n)
1905 fontModule->fontsizeCO->
1906 addItem(toqstr(token(items,'|',n)));
1908 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1909 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1910 fontModule->fontsizeCO->setCurrentIndex(n);
1917 bool GuiDocument::ot1() const
1919 QString const fontenc =
1920 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
1921 return (fontenc == "default"
1922 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
1923 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
1927 bool GuiDocument::completeFontset() const
1929 return (fontModule->fontsSansCO->itemData(
1930 fontModule->fontsSansCO->currentIndex()).toString() == "default"
1931 && fontModule->fontsSansCO->itemData(
1932 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
1936 bool GuiDocument::noMathFont() const
1938 return (fontModule->fontsMathCO->itemData(
1939 fontModule->fontsMathCO->currentIndex()).toString() == "default");
1943 void GuiDocument::updateTexFonts()
1945 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
1947 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
1948 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
1949 for (; it != end; ++it) {
1950 LaTeXFont lf = it->second;
1951 if (lf.name().empty()) {
1952 LYXERR0("Error: Unnamed font: " << it->first);
1955 docstring const family = lf.family();
1956 docstring guiname = translateIfPossible(lf.guiname());
1957 if (!lf.available(ot1(), noMathFont()))
1958 guiname += _(" (not installed)");
1960 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
1961 else if (family == "sf")
1962 sffonts_.insert(toqstr(guiname), toqstr(it->first));
1963 else if (family == "tt")
1964 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
1965 else if (family == "math")
1966 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
1971 void GuiDocument::updateFontlist()
1973 fontModule->fontsRomanCO->clear();
1974 fontModule->fontsSansCO->clear();
1975 fontModule->fontsTypewriterCO->clear();
1976 fontModule->fontsMathCO->clear();
1978 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
1979 if (fontModule->osFontsCB->isChecked()) {
1980 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1981 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1982 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1983 QString unimath = qt_("Non-TeX Fonts Default");
1984 if (!LaTeXFeatures::isAvailable("unicode-math"))
1985 unimath += qt_(" (not available)");
1986 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
1987 fontModule->fontsMathCO->addItem(unimath, QString("default"));
1989 QFontDatabase fontdb;
1990 QStringList families(fontdb.families());
1991 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1992 fontModule->fontsRomanCO->addItem(*it, *it);
1993 fontModule->fontsSansCO->addItem(*it, *it);
1994 fontModule->fontsTypewriterCO->addItem(*it, *it);
1999 if (rmfonts_.empty())
2002 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2003 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2004 while (rmi != rmfonts_.constEnd()) {
2005 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2009 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2010 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2011 while (sfi != sffonts_.constEnd()) {
2012 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2016 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2017 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2018 while (tti != ttfonts_.constEnd()) {
2019 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2023 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2024 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2025 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2026 while (mmi != mathfonts_.constEnd()) {
2027 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2033 void GuiDocument::fontencChanged(int item)
2035 fontModule->fontencLE->setEnabled(
2036 fontModule->fontencCO->itemData(item).toString() == "custom");
2037 // The availability of TeX fonts depends on the font encoding
2039 updateFontOptions();
2043 void GuiDocument::updateMathFonts(QString const & rm)
2045 if (fontModule->osFontsCB->isChecked())
2047 QString const math =
2048 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2049 int const i = fontModule->fontsMathCO->findData("default");
2050 if (providesNoMath(rm) && i == -1)
2051 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2052 else if (!providesNoMath(rm) && i != -1) {
2053 int const c = fontModule->fontsMathCO->currentIndex();
2054 fontModule->fontsMathCO->removeItem(i);
2056 fontModule->fontsMathCO->setCurrentIndex(0);
2061 void GuiDocument::romanChanged(int item)
2063 if (fontModule->osFontsCB->isChecked())
2065 QString const font =
2066 fontModule->fontsRomanCO->itemData(item).toString();
2067 fontModule->fontScCB->setEnabled(providesSC(font));
2068 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2069 updateMathFonts(font);
2073 void GuiDocument::sansChanged(int item)
2075 if (fontModule->osFontsCB->isChecked())
2077 QString const font =
2078 fontModule->fontsSansCO->itemData(item).toString();
2079 bool scaleable = providesScale(font);
2080 fontModule->scaleSansSB->setEnabled(scaleable);
2081 fontModule->scaleSansLA->setEnabled(scaleable);
2085 void GuiDocument::ttChanged(int item)
2087 if (fontModule->osFontsCB->isChecked())
2089 QString const font =
2090 fontModule->fontsTypewriterCO->itemData(item).toString();
2091 bool scaleable = providesScale(font);
2092 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2093 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2097 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2100 pageLayoutModule->pagestyleCO->clear();
2101 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2103 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2104 string style = token(items, '|', n);
2105 QString style_gui = qt_(style);
2106 pagestyles.push_back(pair<string, QString>(style, style_gui));
2107 pageLayoutModule->pagestyleCO->addItem(style_gui);
2110 if (sel == "default") {
2111 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2117 for (size_t i = 0; i < pagestyles.size(); ++i)
2118 if (pagestyles[i].first == sel)
2119 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2122 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2126 void GuiDocument::browseLayout()
2128 QString const label1 = qt_("Layouts|#o#O");
2129 QString const dir1 = toqstr(lyxrc.document_path);
2130 QStringList const filter(qt_("LyX Layout (*.layout)"));
2131 QString file = browseRelToParent(QString(), bufferFilePath(),
2132 qt_("Local layout file"), filter, false,
2135 if (!file.endsWith(".layout"))
2138 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2139 fromqstr(bufferFilePath()));
2141 int const ret = Alert::prompt(_("Local layout file"),
2142 _("The layout file you have selected is a local layout\n"
2143 "file, not one in the system or user directory.\n"
2144 "Your document will not work with this layout if you\n"
2145 "move the layout file to a different directory."),
2146 1, 1, _("&Set Layout"), _("&Cancel"));
2150 // load the layout file
2151 LayoutFileList & bcl = LayoutFileList::get();
2152 string classname = layoutFile.onlyFileName();
2153 // this will update an existing layout if that layout has been loaded before.
2154 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2155 classname.substr(0, classname.size() - 7),
2156 layoutFile.onlyPath().absFileName()));
2159 Alert::error(_("Error"),
2160 _("Unable to read local layout file."));
2164 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2166 // do not trigger classChanged if there is no change.
2167 if (latexModule->classCO->currentText() == toqstr(name))
2171 bool const avail = latexModule->classCO->set(toqstr(name));
2173 LayoutFile const & tc = bcl[name];
2174 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2175 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2176 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2177 tooltip += '\n' + qt_("This is a local layout file.");
2178 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2179 toqstr(translateIfPossible(from_utf8(tc.category()))),
2181 true, true, true, true);
2182 latexModule->classCO->set(toqstr(name));
2189 void GuiDocument::browseMaster()
2191 QString const title = qt_("Select master document");
2192 QString const dir1 = toqstr(lyxrc.document_path);
2193 QString const old = latexModule->childDocLE->text();
2194 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2195 QStringList const filter(qt_("LyX Files (*.lyx)"));
2196 QString file = browseRelToSub(old, docpath, title, filter, false,
2197 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2199 if (!file.isEmpty())
2200 latexModule->childDocLE->setText(file);
2204 void GuiDocument::classChanged_adaptor()
2206 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2211 void GuiDocument::classChanged()
2213 int idx = latexModule->classCO->currentIndex();
2216 string const classname = fromqstr(latexModule->classCO->getData(idx));
2218 if (applyPB->isEnabled()) {
2219 int const ret = Alert::prompt(_("Unapplied changes"),
2220 _("Some changes in the dialog were not yet applied.\n"
2221 "If you do not apply now, they will be lost after this action."),
2222 1, 1, _("&Apply"), _("&Dismiss"));
2227 // We load the TextClass as soon as it is selected. This is
2228 // necessary so that other options in the dialog can be updated
2229 // according to the new class. Note, however, that, if you use
2230 // the scroll wheel when sitting on the combo box, we'll load a
2231 // lot of TextClass objects very quickly....
2232 if (!bp_.setBaseClass(classname)) {
2233 Alert::error(_("Error"), _("Unable to set document class."));
2236 if (lyxrc.auto_reset_options)
2237 bp_.useClassDefaults();
2239 // With the introduction of modules came a distinction between the base
2240 // class and the document class. The former corresponds to the main layout
2241 // file; the latter is that plus the modules (or the document-specific layout,
2242 // or whatever else there could be). Our parameters come from the document
2243 // class. So when we set the base class, we also need to recreate the document
2244 // class. Otherwise, we still have the old one.
2245 bp_.makeDocumentClass();
2250 void GuiDocument::languagePackageChanged(int i)
2252 langModule->languagePackageLE->setEnabled(
2253 langModule->languagePackageCO->itemData(i).toString() == "custom");
2257 void GuiDocument::biblioChanged()
2259 biblioChanged_ = true;
2264 void GuiDocument::bibtexChanged(int n)
2266 biblioModule->bibtexOptionsLE->setEnabled(
2267 biblioModule->bibtexCO->itemData(n).toString() != "default");
2272 void GuiDocument::setAuthorYear(bool authoryear)
2275 biblioModule->citeStyleCO->setCurrentIndex(0);
2280 void GuiDocument::setNumerical(bool numerical)
2283 biblioModule->citeStyleCO->setCurrentIndex(1);
2288 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2290 engine_types_.clear();
2294 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2296 string style = token(items, '|', n);
2297 engine_types_.push_back(style);
2301 case ENGINE_TYPE_AUTHORYEAR:
2302 biblioModule->citeStyleCO->setCurrentIndex(0);
2304 case ENGINE_TYPE_NUMERICAL:
2305 case ENGINE_TYPE_DEFAULT:
2306 biblioModule->citeStyleCO->setCurrentIndex(1);
2310 biblioModule->citationStyleL->setEnabled(nn > 1);
2311 biblioModule->citeStyleCO->setEnabled(nn > 1);
2316 // If the textclass allows only one of authoryear or numerical,
2317 // we have no choice but to force that engine type.
2318 if (engine_types_[0] == "authoryear")
2319 biblioModule->citeStyleCO->setCurrentIndex(0);
2321 biblioModule->citeStyleCO->setCurrentIndex(1);
2327 // both of these should take a vector<docstring>
2329 // This is an insanely complicated attempt to make this sort of thing
2330 // work with RTL languages.
2331 docstring formatStrVec(vector<string> const & v, docstring const & s)
2333 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2337 return translateIfPossible(from_utf8(v[0]));
2338 if (v.size() == 2) {
2339 docstring retval = _("%1$s and %2$s");
2340 retval = subst(retval, _("and"), s);
2341 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2342 translateIfPossible(from_utf8(v[1])));
2344 // The idea here is to format all but the last two items...
2345 int const vSize = v.size();
2346 docstring t2 = _("%1$s, %2$s");
2347 docstring retval = translateIfPossible(from_utf8(v[0]));
2348 for (int i = 1; i < vSize - 2; ++i)
2349 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2350 //...and then to plug them, and the last two, into this schema
2351 docstring t = _("%1$s, %2$s, and %3$s");
2352 t = subst(t, _("and"), s);
2353 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2354 translateIfPossible(from_utf8(v[vSize - 1])));
2357 vector<string> idsToNames(vector<string> const & idList)
2359 vector<string> retval;
2360 vector<string>::const_iterator it = idList.begin();
2361 vector<string>::const_iterator end = idList.end();
2362 for (; it != end; ++it) {
2363 LyXModule const * const mod = theModuleList[*it];
2365 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2366 translateIfPossible(from_utf8(*it)))));
2368 retval.push_back(mod->getName());
2372 } // end anonymous namespace
2375 void GuiDocument::modulesToParams(BufferParams & bp)
2377 // update list of loaded modules
2378 bp.clearLayoutModules();
2379 int const srows = modules_sel_model_.rowCount();
2380 for (int i = 0; i < srows; ++i)
2381 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2383 // update the list of removed modules
2384 bp.clearRemovedModules();
2385 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2386 list<string>::const_iterator rit = reqmods.begin();
2387 list<string>::const_iterator ren = reqmods.end();
2389 // check each of the default modules
2390 for (; rit != ren; ++rit) {
2391 list<string>::const_iterator mit = bp.getModules().begin();
2392 list<string>::const_iterator men = bp.getModules().end();
2394 for (; mit != men; ++mit) {
2401 // the module isn't present so must have been removed by the user
2402 bp.addRemovedModule(*rit);
2407 void GuiDocument::modulesChanged()
2409 modulesToParams(bp_);
2411 if (applyPB->isEnabled() && nonModuleChanged_) {
2412 int const ret = Alert::prompt(_("Unapplied changes"),
2413 _("Some changes in the dialog were not yet applied.\n"
2414 "If you do not apply now, they will be lost after this action."),
2415 1, 1, _("&Apply"), _("&Dismiss"));
2420 bp_.makeDocumentClass();
2426 void GuiDocument::updateModuleInfo()
2428 selectionManager->update();
2430 //Module description
2431 bool const focus_on_selected = selectionManager->selectedFocused();
2432 QAbstractItemView * lv;
2433 if (focus_on_selected)
2434 lv = modulesModule->selectedLV;
2436 lv = modulesModule->availableLV;
2437 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2438 modulesModule->infoML->document()->clear();
2441 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2442 GuiIdListModel const & id_model =
2443 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2444 string const modName = id_model.getIDString(idx.row());
2445 docstring desc = getModuleDescription(modName);
2447 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2448 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2451 desc += _("Module provided by document class.");
2454 docstring cat = getModuleCategory(modName);
2458 desc += bformat(_("Category: %1$s."), cat);
2461 vector<string> pkglist = getPackageList(modName);
2462 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2463 if (!pkgdesc.empty()) {
2466 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2469 pkglist = getRequiredList(modName);
2470 if (!pkglist.empty()) {
2471 vector<string> const reqdescs = idsToNames(pkglist);
2472 pkgdesc = formatStrVec(reqdescs, _("or"));
2475 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2478 pkglist = getExcludedList(modName);
2479 if (!pkglist.empty()) {
2480 vector<string> const reqdescs = idsToNames(pkglist);
2481 pkgdesc = formatStrVec(reqdescs, _( "and"));
2484 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2487 if (!isModuleAvailable(modName)) {
2490 desc += _("WARNING: Some required packages are unavailable!");
2493 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2497 void GuiDocument::updateNumbering()
2499 DocumentClass const & tclass = documentClass();
2501 numberingModule->tocTW->setUpdatesEnabled(false);
2502 numberingModule->tocTW->clear();
2504 int const depth = numberingModule->depthSL->value();
2505 int const toc = numberingModule->tocSL->value();
2506 QString const no = qt_("No");
2507 QString const yes = qt_("Yes");
2508 QTreeWidgetItem * item = 0;
2510 DocumentClass::const_iterator lit = tclass.begin();
2511 DocumentClass::const_iterator len = tclass.end();
2512 for (; lit != len; ++lit) {
2513 int const toclevel = lit->toclevel;
2514 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2515 item = new QTreeWidgetItem(numberingModule->tocTW);
2516 item->setText(0, toqstr(translateIfPossible(lit->name())));
2517 item->setText(1, (toclevel <= depth) ? yes : no);
2518 item->setText(2, (toclevel <= toc) ? yes : no);
2522 numberingModule->tocTW->setUpdatesEnabled(true);
2523 numberingModule->tocTW->update();
2527 void GuiDocument::updateDefaultFormat()
2531 // make a copy in order to consider unapplied changes
2532 BufferParams param_copy = buffer().params();
2533 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2534 int const idx = latexModule->classCO->currentIndex();
2536 string const classname = fromqstr(latexModule->classCO->getData(idx));
2537 param_copy.setBaseClass(classname);
2538 param_copy.makeDocumentClass(true);
2540 outputModule->defaultFormatCO->blockSignals(true);
2541 outputModule->defaultFormatCO->clear();
2542 outputModule->defaultFormatCO->addItem(qt_("Default"),
2543 QVariant(QString("default")));
2544 typedef vector<Format const *> Formats;
2545 Formats formats = param_copy.exportableFormats(true);
2546 sort(formats.begin(), formats.end(), Format::formatSorter);
2547 Formats::const_iterator cit = formats.begin();
2548 Formats::const_iterator end = formats.end();
2549 for (; cit != end; ++cit)
2550 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2551 QVariant(toqstr((*cit)->name())));
2552 outputModule->defaultFormatCO->blockSignals(false);
2556 bool GuiDocument::isChildIncluded(string const & child)
2558 if (includeonlys_.empty())
2560 return (std::find(includeonlys_.begin(),
2561 includeonlys_.end(), child) != includeonlys_.end());
2565 void GuiDocument::applyView()
2568 preambleModule->apply(bp_);
2569 localLayout->apply(bp_);
2572 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2573 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2576 if (biblioModule->citeNatbibRB->isChecked())
2577 bp_.setCiteEngine("natbib");
2578 else if (biblioModule->citeJurabibRB->isChecked())
2579 bp_.setCiteEngine("jurabib");
2580 if (biblioModule->citeDefaultRB->isChecked()) {
2581 bp_.setCiteEngine("basic");
2582 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2585 if (biblioModule->citeStyleCO->currentIndex())
2586 bp_.setCiteEngineType(ENGINE_TYPE_NUMERICAL);
2588 bp_.setCiteEngineType(ENGINE_TYPE_AUTHORYEAR);
2591 biblioModule->bibtopicCB->isChecked();
2593 bp_.biblio_style = fromqstr(biblioModule->bibtexStyleLE->text());
2595 string const bibtex_command =
2596 fromqstr(biblioModule->bibtexCO->itemData(
2597 biblioModule->bibtexCO->currentIndex()).toString());
2598 string const bibtex_options =
2599 fromqstr(biblioModule->bibtexOptionsLE->text());
2600 if (bibtex_command == "default" || bibtex_options.empty())
2601 bp_.bibtex_command = bibtex_command;
2603 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2605 if (biblioChanged_) {
2606 buffer().invalidateBibinfoCache();
2607 buffer().removeBiblioTempFiles();
2611 indicesModule->apply(bp_);
2613 // language & quotes
2614 if (langModule->defaultencodingRB->isChecked()) {
2615 bp_.inputenc = "auto";
2617 int i = langModule->encodingCO->currentIndex();
2619 bp_.inputenc = "default";
2621 QString const enc_gui =
2622 langModule->encodingCO->currentText();
2623 Encodings::const_iterator it = encodings.begin();
2624 Encodings::const_iterator const end = encodings.end();
2626 for (; it != end; ++it) {
2627 if (qt_(it->guiName()) == enc_gui &&
2629 bp_.inputenc = it->name();
2635 // should not happen
2636 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2637 bp_.inputenc = "default";
2642 bp_.quotes_language = (InsetQuotes::QuoteLanguage) langModule->quoteStyleCO->itemData(
2643 langModule->quoteStyleCO->currentIndex()).toInt();
2645 QString const langname = langModule->languageCO->itemData(
2646 langModule->languageCO->currentIndex()).toString();
2647 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2648 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2649 // If current cursor language was the document language, then update it too.
2650 if (cur.current_font.language() == bp_.language) {
2651 cur.current_font.setLanguage(newlang);
2652 cur.real_current_font.setLanguage(newlang);
2654 bp_.language = newlang;
2656 QString const pack = langModule->languagePackageCO->itemData(
2657 langModule->languagePackageCO->currentIndex()).toString();
2658 if (pack == "custom")
2660 fromqstr(langModule->languagePackageLE->text());
2662 bp_.lang_package = fromqstr(pack);
2665 bp_.backgroundcolor = set_backgroundcolor;
2666 bp_.isbackgroundcolor = is_backgroundcolor;
2667 bp_.fontcolor = set_fontcolor;
2668 bp_.isfontcolor = is_fontcolor;
2669 bp_.notefontcolor = set_notefontcolor;
2670 bp_.boxbgcolor = set_boxbgcolor;
2673 if (bp_.documentClass().hasTocLevels()) {
2674 bp_.tocdepth = numberingModule->tocSL->value();
2675 bp_.secnumdepth = numberingModule->depthSL->value();
2679 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2680 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2681 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2682 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2685 bp_.graphics_driver =
2686 tex_graphics[latexModule->psdriverCO->currentIndex()];
2689 int idx = latexModule->classCO->currentIndex();
2691 string const classname = fromqstr(latexModule->classCO->getData(idx));
2692 bp_.setBaseClass(classname);
2696 modulesToParams(bp_);
2699 map<string, string> const & packages = BufferParams::auto_packages();
2700 for (map<string, string>::const_iterator it = packages.begin();
2701 it != packages.end(); ++it) {
2702 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2705 int row = mathsModule->packagesTW->row(item);
2706 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2707 if (rb->isChecked()) {
2708 bp_.use_package(it->first, BufferParams::package_auto);
2711 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2712 if (rb->isChecked()) {
2713 bp_.use_package(it->first, BufferParams::package_on);
2716 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2717 if (rb->isChecked())
2718 bp_.use_package(it->first, BufferParams::package_off);
2722 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2723 bp_.pagestyle = "default";
2725 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2726 for (size_t i = 0; i != pagestyles.size(); ++i)
2727 if (pagestyles[i].second == style_gui)
2728 bp_.pagestyle = pagestyles[i].first;
2732 switch (textLayoutModule->lspacingCO->currentIndex()) {
2734 bp_.spacing().set(Spacing::Single);
2737 bp_.spacing().set(Spacing::Onehalf);
2740 bp_.spacing().set(Spacing::Double);
2743 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2745 bp_.spacing().set(Spacing::Single);
2747 bp_.spacing().set(Spacing::Other, s);
2752 if (textLayoutModule->twoColumnCB->isChecked())
2757 bp_.justification = textLayoutModule->justCB->isChecked();
2759 if (textLayoutModule->indentRB->isChecked()) {
2760 // if paragraphs are separated by an indentation
2761 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2762 switch (textLayoutModule->indentCO->currentIndex()) {
2764 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2767 HSpace indent = HSpace(
2768 widgetsToLength(textLayoutModule->indentLE,
2769 textLayoutModule->indentLengthCO)
2771 bp_.setIndentation(indent);
2775 // this should never happen
2776 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2780 // if paragraphs are separated by a skip
2781 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2782 switch (textLayoutModule->skipCO->currentIndex()) {
2784 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2787 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2790 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2795 widgetsToLength(textLayoutModule->skipLE,
2796 textLayoutModule->skipLengthCO)
2802 // this should never happen
2803 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2809 fromqstr(latexModule->optionsLE->text());
2811 bp_.use_default_options =
2812 latexModule->defaultOptionsCB->isChecked();
2814 if (latexModule->childDocGB->isChecked())
2816 fromqstr(latexModule->childDocLE->text());
2818 bp_.master = string();
2821 bp_.clearIncludedChildren();
2822 if (masterChildModule->includeonlyRB->isChecked()) {
2823 list<string>::const_iterator it = includeonlys_.begin();
2824 for (; it != includeonlys_.end() ; ++it) {
2825 bp_.addIncludedChildren(*it);
2828 bp_.maintain_unincluded_children =
2829 masterChildModule->maintainAuxCB->isChecked();
2832 bp_.float_placement = floatModule->get();
2835 // text should have passed validation
2836 bp_.listings_params =
2837 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2840 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2841 outputModule->defaultFormatCO->currentIndex()).toString());
2843 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2844 bp_.useNonTeXFonts = nontexfonts;
2846 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2848 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2850 int mathfmt = outputModule->mathoutCB->currentIndex();
2853 BufferParams::MathOutput const mo =
2854 static_cast<BufferParams::MathOutput>(mathfmt);
2855 bp_.html_math_output = mo;
2856 bp_.html_be_strict = outputModule->strictCB->isChecked();
2857 bp_.html_css_as_file = outputModule->cssCB->isChecked();
2858 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2859 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
2862 bp_.fonts_roman[nontexfonts] =
2863 fromqstr(fontModule->fontsRomanCO->
2864 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2865 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
2867 bp_.fonts_sans[nontexfonts] =
2868 fromqstr(fontModule->fontsSansCO->
2869 itemData(fontModule->fontsSansCO->currentIndex()).toString());
2870 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
2872 bp_.fonts_typewriter[nontexfonts] =
2873 fromqstr(fontModule->fontsTypewriterCO->
2874 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2875 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
2877 bp_.fonts_math[nontexfonts] =
2878 fromqstr(fontModule->fontsMathCO->
2879 itemData(fontModule->fontsMathCO->currentIndex()).toString());
2880 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
2882 QString const fontenc =
2883 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
2884 if (fontenc == "custom")
2885 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2887 bp_.fontenc = fromqstr(fontenc);
2890 fromqstr(fontModule->cjkFontLE->text());
2892 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
2893 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
2895 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
2896 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
2898 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2900 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2903 bp_.fonts_default_family = "default";
2905 bp_.fonts_default_family = GuiDocument::fontfamilies[
2906 fontModule->fontsDefaultCO->currentIndex()];
2908 if (fontModule->fontsizeCO->currentIndex() == 0)
2909 bp_.fontsize = "default";
2912 fromqstr(fontModule->fontsizeCO->currentText());
2915 bp_.papersize = PAPER_SIZE(
2916 pageLayoutModule->papersizeCO->currentIndex());
2918 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2919 pageLayoutModule->paperwidthUnitCO);
2921 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2922 pageLayoutModule->paperheightUnitCO);
2924 if (pageLayoutModule->facingPagesCB->isChecked())
2925 bp_.sides = TwoSides;
2927 bp_.sides = OneSide;
2929 if (pageLayoutModule->landscapeRB->isChecked())
2930 bp_.orientation = ORIENTATION_LANDSCAPE;
2932 bp_.orientation = ORIENTATION_PORTRAIT;
2935 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2937 Ui::MarginsUi const * m = marginsModule;
2939 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2940 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2941 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2942 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2943 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2944 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2945 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2946 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2949 branchesModule->apply(bp_);
2952 PDFOptions & pdf = bp_.pdfoptions();
2953 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2954 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2955 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2956 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2957 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2959 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2960 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2961 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2962 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2964 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2965 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2966 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2967 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2969 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2970 if (pdfSupportModule->fullscreenCB->isChecked())
2971 pdf.pagemode = pdf.pagemode_fullscreen;
2973 pdf.pagemode.clear();
2974 pdf.quoted_options = pdf.quoted_options_check(
2975 fromqstr(pdfSupportModule->optionsLE->text()));
2978 nonModuleChanged_ = false;
2982 void GuiDocument::paramsToDialog()
2984 // set the default unit
2985 Length::UNIT const default_unit = Length::defaultUnit();
2988 preambleModule->update(bp_, id());
2989 localLayout->update(bp_, id());
2992 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2993 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2996 string const cite_engine = bp_.citeEngine().list().front();
2998 biblioModule->citeDefaultRB->setChecked(
2999 cite_engine == "basic");
3001 biblioModule->citeJurabibRB->setChecked(
3002 cite_engine == "jurabib");
3004 biblioModule->citeNatbibRB->setChecked(
3005 cite_engine == "natbib");
3007 biblioModule->citeStyleCO->setCurrentIndex(
3008 bp_.citeEngineType() & ENGINE_TYPE_NUMERICAL);
3010 updateEngineType(documentClass().opt_enginetype(),
3011 bp_.citeEngineType());
3013 biblioModule->bibtopicCB->setChecked(
3016 biblioModule->bibtexStyleLE->setText(toqstr(bp_.biblio_style));
3020 split(bp_.bibtex_command, command, ' ');
3022 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3024 biblioModule->bibtexCO->setCurrentIndex(bpos);
3025 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3027 // We reset to default if we do not know the specified compiler
3028 // This is for security reasons
3029 biblioModule->bibtexCO->setCurrentIndex(
3030 biblioModule->bibtexCO->findData(toqstr("default")));
3031 biblioModule->bibtexOptionsLE->clear();
3033 biblioModule->bibtexOptionsLE->setEnabled(
3034 biblioModule->bibtexCO->currentIndex() != 0);
3036 biblioChanged_ = false;
3039 // We may be called when there is no Buffer, e.g., when
3040 // the last view has just been closed.
3041 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3042 indicesModule->update(bp_, isReadOnly);
3044 // language & quotes
3045 int const pos = langModule->languageCO->findData(toqstr(
3046 bp_.language->lang()));
3047 langModule->languageCO->setCurrentIndex(pos);
3049 langModule->quoteStyleCO->setCurrentIndex(
3050 bp_.quotes_language);
3052 bool default_enc = true;
3053 if (bp_.inputenc != "auto") {
3054 default_enc = false;
3055 if (bp_.inputenc == "default") {
3056 langModule->encodingCO->setCurrentIndex(0);
3059 Encodings::const_iterator it = encodings.begin();
3060 Encodings::const_iterator const end = encodings.end();
3061 for (; it != end; ++it) {
3062 if (it->name() == bp_.inputenc &&
3064 enc_gui = it->guiName();
3068 int const i = langModule->encodingCO->findText(
3071 langModule->encodingCO->setCurrentIndex(i);
3073 // unknown encoding. Set to default.
3077 langModule->defaultencodingRB->setChecked(default_enc);
3078 langModule->otherencodingRB->setChecked(!default_enc);
3080 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3082 langModule->languagePackageCO->setCurrentIndex(
3083 langModule->languagePackageCO->findData("custom"));
3084 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3086 langModule->languagePackageCO->setCurrentIndex(p);
3087 langModule->languagePackageLE->clear();
3091 if (bp_.isfontcolor) {
3092 colorModule->fontColorPB->setStyleSheet(
3093 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3095 set_fontcolor = bp_.fontcolor;
3096 is_fontcolor = bp_.isfontcolor;
3098 colorModule->noteFontColorPB->setStyleSheet(
3099 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3100 set_notefontcolor = bp_.notefontcolor;
3102 if (bp_.isbackgroundcolor) {
3103 colorModule->backgroundPB->setStyleSheet(
3104 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3106 set_backgroundcolor = bp_.backgroundcolor;
3107 is_backgroundcolor = bp_.isbackgroundcolor;
3109 colorModule->boxBackgroundPB->setStyleSheet(
3110 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3111 set_boxbgcolor = bp_.boxbgcolor;
3114 int const min_toclevel = documentClass().min_toclevel();
3115 int const max_toclevel = documentClass().max_toclevel();
3116 if (documentClass().hasTocLevels()) {
3117 numberingModule->setEnabled(true);
3118 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3119 numberingModule->depthSL->setMaximum(max_toclevel);
3120 numberingModule->depthSL->setValue(bp_.secnumdepth);
3121 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3122 numberingModule->tocSL->setMaximum(max_toclevel);
3123 numberingModule->tocSL->setValue(bp_.tocdepth);
3126 numberingModule->setEnabled(false);
3127 numberingModule->tocTW->clear();
3131 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3132 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3133 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3134 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3135 bulletsModule->init();
3138 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3140 latexModule->psdriverCO->setCurrentIndex(nitem);
3143 map<string, string> const & packages = BufferParams::auto_packages();
3144 for (map<string, string>::const_iterator it = packages.begin();
3145 it != packages.end(); ++it) {
3146 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3149 int row = mathsModule->packagesTW->row(item);
3150 switch (bp_.use_package(it->first)) {
3151 case BufferParams::package_off: {
3152 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3153 rb->setChecked(true);
3156 case BufferParams::package_on: {
3157 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3158 rb->setChecked(true);
3161 case BufferParams::package_auto: {
3162 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3163 rb->setChecked(true);
3169 switch (bp_.spacing().getSpace()) {
3170 case Spacing::Other: nitem = 3; break;
3171 case Spacing::Double: nitem = 2; break;
3172 case Spacing::Onehalf: nitem = 1; break;
3173 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3177 string const & layoutID = bp_.baseClassID();
3178 setLayoutComboByIDString(layoutID);
3180 updatePagestyle(documentClass().opt_pagestyle(),
3183 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3184 if (bp_.spacing().getSpace() == Spacing::Other) {
3185 doubleToWidget(textLayoutModule->lspacingLE,
3186 bp_.spacing().getValueAsString());
3190 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3191 textLayoutModule->indentRB->setChecked(true);
3192 string indentation = bp_.getIndentation().asLyXCommand();
3194 if (indentation != "default") {
3195 lengthToWidgets(textLayoutModule->indentLE,
3196 textLayoutModule->indentLengthCO,
3197 indentation, default_unit);
3200 textLayoutModule->indentCO->setCurrentIndex(indent);
3203 textLayoutModule->skipRB->setChecked(true);
3205 switch (bp_.getDefSkip().kind()) {
3206 case VSpace::SMALLSKIP:
3209 case VSpace::MEDSKIP:
3212 case VSpace::BIGSKIP:
3215 case VSpace::LENGTH:
3218 string const length = bp_.getDefSkip().asLyXCommand();
3219 lengthToWidgets(textLayoutModule->skipLE,
3220 textLayoutModule->skipLengthCO,
3221 length, default_unit);
3228 textLayoutModule->skipCO->setCurrentIndex(skip);
3232 textLayoutModule->twoColumnCB->setChecked(
3234 textLayoutModule->justCB->setChecked(bp_.justification);
3236 if (!bp_.options.empty()) {
3237 latexModule->optionsLE->setText(
3238 toqstr(bp_.options));
3240 latexModule->optionsLE->setText(QString());
3244 latexModule->defaultOptionsCB->setChecked(
3245 bp_.use_default_options);
3246 updateSelectedModules();
3247 selectionManager->updateProvidedModules(
3248 bp_.baseClass()->providedModules());
3249 selectionManager->updateExcludedModules(
3250 bp_.baseClass()->excludedModules());
3252 if (!documentClass().options().empty()) {
3253 latexModule->defaultOptionsLE->setText(
3254 toqstr(documentClass().options()));
3256 latexModule->defaultOptionsLE->setText(
3257 toqstr(_("[No options predefined]")));
3260 latexModule->defaultOptionsLE->setEnabled(
3261 bp_.use_default_options
3262 && !documentClass().options().empty());
3264 latexModule->defaultOptionsCB->setEnabled(
3265 !documentClass().options().empty());
3267 if (!bp_.master.empty()) {
3268 latexModule->childDocGB->setChecked(true);
3269 latexModule->childDocLE->setText(
3270 toqstr(bp_.master));
3272 latexModule->childDocLE->setText(QString());
3273 latexModule->childDocGB->setChecked(false);
3277 if (!bufferview() || !buffer().hasChildren()) {
3278 masterChildModule->childrenTW->clear();
3279 includeonlys_.clear();
3280 docPS->showPanel("Child Documents", false);
3281 if (docPS->isCurrentPanel("Child Documents"))
3282 docPS->setCurrentPanel("Document Class");
3284 docPS->showPanel("Child Documents", true);
3285 masterChildModule->setEnabled(true);
3286 includeonlys_ = bp_.getIncludedChildren();
3287 updateIncludeonlys();
3289 masterChildModule->maintainAuxCB->setChecked(
3290 bp_.maintain_unincluded_children);
3293 floatModule->set(bp_.float_placement);
3296 // break listings_params to multiple lines
3298 InsetListingsParams(bp_.listings_params).separatedParams();
3299 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3302 // some languages only work with polyglossia/XeTeX
3303 Language const * lang = lyx::languages.getLanguage(
3304 fromqstr(langModule->languageCO->itemData(
3305 langModule->languageCO->currentIndex()).toString()));
3306 bool const need_fontspec =
3307 lang->babel().empty() && !lang->polyglossia().empty();
3308 bool const os_fonts_available =
3309 bp_.baseClass()->outputType() == lyx::LATEX
3310 && LaTeXFeatures::isAvailable("fontspec");
3311 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3312 fontModule->osFontsCB->setChecked(
3313 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3314 updateFontsize(documentClass().opt_fontsize(),
3317 QString font = toqstr(bp_.fontsRoman());
3318 int rpos = fontModule->fontsRomanCO->findData(font);
3320 rpos = fontModule->fontsRomanCO->count();
3321 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3323 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3324 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3326 font = toqstr(bp_.fontsSans());
3327 int spos = fontModule->fontsSansCO->findData(font);
3329 spos = fontModule->fontsSansCO->count();
3330 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3332 fontModule->fontsSansCO->setCurrentIndex(spos);
3333 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3335 font = toqstr(bp_.fontsTypewriter());
3336 int tpos = fontModule->fontsTypewriterCO->findData(font);
3338 tpos = fontModule->fontsTypewriterCO->count();
3339 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3341 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3342 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3344 font = toqstr(bp_.fontsMath());
3345 int mpos = fontModule->fontsMathCO->findData(font);
3347 mpos = fontModule->fontsMathCO->count();
3348 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3350 fontModule->fontsMathCO->setCurrentIndex(mpos);
3351 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3353 if (bp_.useNonTeXFonts && os_fonts_available) {
3354 fontModule->fontencLA->setEnabled(false);
3355 fontModule->fontencCO->setEnabled(false);
3356 fontModule->fontencLE->setEnabled(false);
3358 fontModule->fontencLA->setEnabled(true);
3359 fontModule->fontencCO->setEnabled(true);
3360 fontModule->fontencLE->setEnabled(true);
3366 if (!bp_.fonts_cjk.empty())
3367 fontModule->cjkFontLE->setText(
3368 toqstr(bp_.fonts_cjk));
3370 fontModule->cjkFontLE->setText(QString());
3372 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3373 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3374 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3375 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3376 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3377 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3379 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3381 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3383 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3384 fontModule->fontencCO->setCurrentIndex(
3385 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3386 fontModule->fontencLE->setEnabled(false);
3388 fontModule->fontencCO->setCurrentIndex(1);
3389 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3393 // This must be set _after_ fonts since updateDefaultFormat()
3394 // checks osFontsCB settings.
3395 // update combobox with formats
3396 updateDefaultFormat();
3397 int index = outputModule->defaultFormatCO->findData(toqstr(
3398 bp_.default_output_format));
3399 // set to default if format is not found
3402 outputModule->defaultFormatCO->setCurrentIndex(index);
3404 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3405 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3407 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3408 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3409 outputModule->strictCB->setChecked(bp_.html_be_strict);
3410 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3413 bool const extern_geometry =
3414 documentClass().provides("geometry");
3415 int const psize = bp_.papersize;
3416 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3417 setCustomPapersize(!extern_geometry && psize == 1);
3418 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3420 bool const landscape =
3421 bp_.orientation == ORIENTATION_LANDSCAPE;
3422 pageLayoutModule->landscapeRB->setChecked(landscape);
3423 pageLayoutModule->portraitRB->setChecked(!landscape);
3424 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3425 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3427 pageLayoutModule->facingPagesCB->setChecked(
3428 bp_.sides == TwoSides);
3430 lengthToWidgets(pageLayoutModule->paperwidthLE,
3431 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3432 lengthToWidgets(pageLayoutModule->paperheightLE,
3433 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3436 Ui::MarginsUi * m = marginsModule;
3440 lengthToWidgets(m->topLE, m->topUnit,
3441 bp_.topmargin, default_unit);
3443 lengthToWidgets(m->bottomLE, m->bottomUnit,
3444 bp_.bottommargin, default_unit);
3446 lengthToWidgets(m->innerLE, m->innerUnit,
3447 bp_.leftmargin, default_unit);
3449 lengthToWidgets(m->outerLE, m->outerUnit,
3450 bp_.rightmargin, default_unit);
3452 lengthToWidgets(m->headheightLE, m->headheightUnit,
3453 bp_.headheight, default_unit);
3455 lengthToWidgets(m->headsepLE, m->headsepUnit,
3456 bp_.headsep, default_unit);
3458 lengthToWidgets(m->footskipLE, m->footskipUnit,
3459 bp_.footskip, default_unit);
3461 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3462 bp_.columnsep, default_unit);
3465 updateUnknownBranches();
3466 branchesModule->update(bp_);
3469 PDFOptions const & pdf = bp_.pdfoptions();
3470 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3471 if (bp_.documentClass().provides("hyperref"))
3472 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3474 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3475 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3476 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3477 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3478 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3480 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3481 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3482 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3484 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3486 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3487 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3488 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3489 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3491 nn = findToken(backref_opts, pdf.backref);
3493 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3495 pdfSupportModule->fullscreenCB->setChecked
3496 (pdf.pagemode == pdf.pagemode_fullscreen);
3498 pdfSupportModule->optionsLE->setText(
3499 toqstr(pdf.quoted_options));
3501 // Make sure that the bc is in the INITIAL state
3502 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3505 // clear changed branches cache
3506 changedBranches_.clear();
3509 nonModuleChanged_ = false;
3513 void GuiDocument::saveDocDefault()
3515 // we have to apply the params first
3521 void GuiDocument::updateAvailableModules()
3523 modules_av_model_.clear();
3524 list<modInfoStruct> const & modInfoList = getModuleInfo();
3525 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3526 list<modInfoStruct>::const_iterator men = modInfoList.end();
3527 for (int i = 0; mit != men; ++mit, ++i)
3528 modules_av_model_.insertRow(i, mit->name, mit->id,
3533 void GuiDocument::updateSelectedModules()
3535 modules_sel_model_.clear();
3536 list<modInfoStruct> const selModList = getSelectedModules();
3537 list<modInfoStruct>::const_iterator mit = selModList.begin();
3538 list<modInfoStruct>::const_iterator men = selModList.end();
3539 for (int i = 0; mit != men; ++mit, ++i)
3540 modules_sel_model_.insertRow(i, mit->name, mit->id,
3545 void GuiDocument::updateIncludeonlys()
3547 masterChildModule->childrenTW->clear();
3548 QString const no = qt_("No");
3549 QString const yes = qt_("Yes");
3551 if (includeonlys_.empty()) {
3552 masterChildModule->includeallRB->setChecked(true);
3553 masterChildModule->childrenTW->setEnabled(false);
3554 masterChildModule->maintainAuxCB->setEnabled(false);
3556 masterChildModule->includeonlyRB->setChecked(true);
3557 masterChildModule->childrenTW->setEnabled(true);
3558 masterChildModule->maintainAuxCB->setEnabled(true);
3560 ListOfBuffers children = buffer().getChildren();
3561 ListOfBuffers::const_iterator it = children.begin();
3562 ListOfBuffers::const_iterator end = children.end();
3563 bool has_unincluded = false;
3564 bool all_unincluded = true;
3565 for (; it != end; ++it) {
3566 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3569 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3570 from_utf8(buffer().filePath())));
3571 item->setText(0, toqstr(name));
3572 item->setText(1, isChildIncluded(name) ? yes : no);
3573 if (!isChildIncluded(name))
3574 has_unincluded = true;
3576 all_unincluded = false;
3578 // Both if all childs are included and if none is included
3579 // is equal to "include all" (i.e., ommit \includeonly).
3580 // Thus, reset the GUI.
3581 if (!has_unincluded || all_unincluded) {
3582 masterChildModule->includeallRB->setChecked(true);
3583 masterChildModule->childrenTW->setEnabled(false);
3584 includeonlys_.clear();
3586 // If all are included, we need to update again.
3587 if (!has_unincluded)
3588 updateIncludeonlys();
3592 void GuiDocument::updateContents()
3594 // Nothing to do here as the document settings is not cursor dependant.
3599 void GuiDocument::useClassDefaults()
3601 if (applyPB->isEnabled()) {
3602 int const ret = Alert::prompt(_("Unapplied changes"),
3603 _("Some changes in the dialog were not yet applied.\n"
3604 "If you do not apply now, they will be lost after this action."),
3605 1, 1, _("&Apply"), _("&Dismiss"));
3610 int idx = latexModule->classCO->currentIndex();
3611 string const classname = fromqstr(latexModule->classCO->getData(idx));
3612 if (!bp_.setBaseClass(classname)) {
3613 Alert::error(_("Error"), _("Unable to set document class."));
3616 bp_.useClassDefaults();
3621 void GuiDocument::setLayoutComboByIDString(string const & idString)
3623 if (!latexModule->classCO->set(toqstr(idString)))
3624 Alert::warning(_("Can't set layout!"),
3625 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3629 bool GuiDocument::isValid()
3632 validateListingsParameters().isEmpty() &&
3633 localLayout->isValid() &&
3635 // if we're asking for skips between paragraphs
3636 !textLayoutModule->skipRB->isChecked() ||
3637 // then either we haven't chosen custom
3638 textLayoutModule->skipCO->currentIndex() != 3 ||
3639 // or else a length has been given
3640 !textLayoutModule->skipLE->text().isEmpty()
3643 // if we're asking for indentation
3644 !textLayoutModule->indentRB->isChecked() ||
3645 // then either we haven't chosen custom
3646 textLayoutModule->indentCO->currentIndex() != 1 ||
3647 // or else a length has been given
3648 !textLayoutModule->indentLE->text().isEmpty()
3653 char const * const GuiDocument::fontfamilies[5] = {
3654 "default", "rmdefault", "sfdefault", "ttdefault", ""
3658 char const * GuiDocument::fontfamilies_gui[5] = {
3659 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3663 bool GuiDocument::initialiseParams(string const &)
3665 BufferView const * view = bufferview();
3667 bp_ = BufferParams();
3671 bp_ = view->buffer().params();
3673 updateAvailableModules();
3674 //FIXME It'd be nice to make sure here that the selected
3675 //modules are consistent: That required modules are actually
3676 //selected, and that we don't have conflicts. If so, we could
3677 //at least pop up a warning.
3683 void GuiDocument::clearParams()
3685 bp_ = BufferParams();
3689 BufferId GuiDocument::id() const
3691 BufferView const * const view = bufferview();
3692 return view? &view->buffer() : 0;
3696 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3698 return moduleNames_;
3702 list<GuiDocument::modInfoStruct> const
3703 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3705 LayoutModuleList::const_iterator it = mods.begin();
3706 LayoutModuleList::const_iterator end = mods.end();
3707 list<modInfoStruct> mInfo;
3708 for (; it != end; ++it) {
3711 LyXModule const * const mod = theModuleList[*it];
3714 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3716 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3723 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3725 return makeModuleInfo(params().getModules());
3729 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3731 return makeModuleInfo(params().baseClass()->providedModules());
3735 DocumentClass const & GuiDocument::documentClass() const
3737 return bp_.documentClass();
3741 static void dispatch_bufferparams(Dialog const & dialog,
3742 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
3745 ss << "\\begin_header\n";
3746 bp.writeFile(ss, buf);
3747 ss << "\\end_header\n";
3748 dialog.dispatch(FuncRequest(lfun, ss.str()));
3752 void GuiDocument::dispatchParams()
3754 // We need a non-const buffer object.
3755 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
3756 // There may be several undo records; group them (bug #8998)
3757 buf.undo().beginUndoGroup();
3759 // This must come first so that a language change is correctly noticed
3762 // Apply the BufferParams. Note that this will set the base class
3763 // and then update the buffer's layout.
3764 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
3766 if (!params().master.empty()) {
3767 FileName const master_file = support::makeAbsPath(params().master,
3768 support::onlyPath(buffer().absFileName()));
3769 if (isLyXFileName(master_file.absFileName())) {
3770 Buffer * master = checkAndLoadLyXFile(master_file);
3772 if (master->isChild(const_cast<Buffer *>(&buffer())))
3773 const_cast<Buffer &>(buffer()).setParent(master);
3775 Alert::warning(_("Assigned master does not include this file"),
3776 bformat(_("You must include this file in the document\n"
3777 "'%1$s' in order to use the master document\n"
3778 "feature."), from_utf8(params().master)));
3780 Alert::warning(_("Could not load master"),
3781 bformat(_("The master document '%1$s'\n"
3782 "could not be loaded."),
3783 from_utf8(params().master)));
3787 // Generate the colours requested by each new branch.
3788 BranchList & branchlist = params().branchlist();
3789 if (!branchlist.empty()) {
3790 BranchList::const_iterator it = branchlist.begin();
3791 BranchList::const_iterator const end = branchlist.end();
3792 for (; it != end; ++it) {
3793 docstring const & current_branch = it->branch();
3794 Branch const * branch = branchlist.find(current_branch);
3795 string const x11hexname = X11hexname(branch->color());
3796 // display the new color
3797 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3798 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3801 // Open insets of selected branches, close deselected ones
3802 dispatch(FuncRequest(LFUN_INSET_FORALL,
3803 "Branch inset-toggle assign"));
3805 // rename branches in the document
3806 executeBranchRenaming();
3807 // and clear changed branches cache
3808 changedBranches_.clear();
3810 // Generate the colours requested by indices.
3811 IndicesList & indiceslist = params().indiceslist();
3812 if (!indiceslist.empty()) {
3813 IndicesList::const_iterator it = indiceslist.begin();
3814 IndicesList::const_iterator const end = indiceslist.end();
3815 for (; it != end; ++it) {
3816 docstring const & current_index = it->shortcut();
3817 Index const * index = indiceslist.findShortcut(current_index);
3818 string const x11hexname = X11hexname(index->color());
3819 // display the new color
3820 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3821 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3825 // If we used an LFUN, we would not need these two lines:
3826 BufferView * bv = const_cast<BufferView *>(bufferview());
3827 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3829 // Don't forget to close the group. Note that it is important
3830 // to check that there is no early return in the method.
3831 buf.undo().endUndoGroup();
3835 void GuiDocument::setLanguage() const
3837 Language const * const newL = bp_.language;
3838 if (buffer().params().language == newL)
3841 string const & lang_name = newL->lang();
3842 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3846 void GuiDocument::saveAsDefault() const
3848 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
3852 bool GuiDocument::providesOSF(QString const & font) const
3854 if (fontModule->osFontsCB->isChecked())
3855 // FIXME: we should check if the fonts really
3856 // have OSF support. But how?
3858 return theLaTeXFonts().getLaTeXFont(
3859 qstring_to_ucs4(font)).providesOSF(ot1(),
3865 bool GuiDocument::providesSC(QString const & font) const
3867 if (fontModule->osFontsCB->isChecked())
3869 return theLaTeXFonts().getLaTeXFont(
3870 qstring_to_ucs4(font)).providesSC(ot1(),
3876 bool GuiDocument::providesScale(QString const & font) const
3878 if (fontModule->osFontsCB->isChecked())
3880 return theLaTeXFonts().getLaTeXFont(
3881 qstring_to_ucs4(font)).providesScale(ot1(),
3887 bool GuiDocument::providesNoMath(QString const & font) const
3889 if (fontModule->osFontsCB->isChecked())
3891 return theLaTeXFonts().getLaTeXFont(
3892 qstring_to_ucs4(font)).providesNoMath(ot1(),
3897 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
3899 if (fontModule->osFontsCB->isChecked())
3901 return theLaTeXFonts().getLaTeXFont(
3902 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
3908 void GuiDocument::loadModuleInfo()
3910 moduleNames_.clear();
3911 LyXModuleList::const_iterator it = theModuleList.begin();
3912 LyXModuleList::const_iterator end = theModuleList.end();
3913 for (; it != end; ++it) {
3917 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3918 // this is supposed to give us the first sentence of the description
3921 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3922 int const pos = desc.indexOf(".");
3924 desc.truncate(pos + 1);
3925 m.description = desc;
3926 if (it->category().substr(0, 8) != "Citation")
3927 moduleNames_.push_back(m);
3932 void GuiDocument::updateUnknownBranches()
3936 list<docstring> used_branches;
3937 buffer().getUsedBranches(used_branches);
3938 list<docstring>::const_iterator it = used_branches.begin();
3939 QStringList unknown_branches;
3940 for (; it != used_branches.end() ; ++it) {
3941 if (!buffer().params().branchlist().find(*it))
3942 unknown_branches.append(toqstr(*it));
3944 branchesModule->setUnknownBranches(unknown_branches);
3948 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3950 map<docstring, docstring>::iterator it = changedBranches_.begin();
3951 for (; it != changedBranches_.end() ; ++it) {
3952 if (it->second == oldname) {
3953 // branch has already been renamed
3954 it->second = newname;
3959 changedBranches_[oldname] = newname;
3963 void GuiDocument::executeBranchRenaming() const
3965 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3966 for (; it != changedBranches_.end() ; ++it) {
3967 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3968 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3973 void GuiDocument::allPackagesAuto()
3979 void GuiDocument::allPackagesAlways()
3985 void GuiDocument::allPackagesNot()
3991 void GuiDocument::allPackages(int col)
3993 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
3994 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
3995 rb->setChecked(true);
4000 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4003 } // namespace frontend
4006 #include "moc_GuiDocument.cpp"