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 "GuiApplication.h"
17 #include "GuiBranches.h"
18 #include "GuiIndices.h"
19 #include "GuiSelectionManager.h"
20 #include "LaTeXHighlighter.h"
21 #include "LengthCombo.h"
22 #include "PanelStack.h"
23 #include "Validator.h"
25 #include "LayoutFile.h"
26 #include "BranchList.h"
27 #include "buffer_funcs.h"
29 #include "BufferParams.h"
30 #include "BufferView.h"
32 #include "ColorCache.h"
34 #include "FloatPlacement.h"
36 #include "FuncRequest.h"
38 #include "IndicesList.h"
40 #include "LaTeXFeatures.h"
42 #include "LayoutModuleList.h"
44 #include "ModuleList.h"
45 #include "OutputParams.h"
46 #include "PDFOptions.h"
47 #include "qt_helpers.h"
49 #include "TextClass.h"
51 #include "insets/InsetListingsParams.h"
53 #include "support/debug.h"
54 #include "support/FileName.h"
55 #include "support/filetools.h"
56 #include "support/gettext.h"
57 #include "support/lstrings.h"
59 #include "frontends/alert.h"
61 #include <QAbstractItemModel>
62 #include <QHeaderView>
64 #include <QColorDialog>
65 #include <QCloseEvent>
66 #include <QFontDatabase>
68 #include <QTextCursor>
78 // a style sheet for buttons
79 // this is for example used for the background color setting button
80 static inline QString colorButtonStyleSheet(QColor const & bgColor)
82 if (bgColor.isValid()) {
83 QString rc = QLatin1String("background-color:");
92 using namespace lyx::support;
97 char const * const tex_graphics[] =
99 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
100 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
101 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
102 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
107 char const * const tex_graphics_gui[] =
109 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
110 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
111 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
112 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
113 "XeTeX", N_("None"), ""
117 char const * const tex_fonts_roman[] =
119 "default", "cmr", "lmodern", "ae", "times", "palatino",
120 "charter", "newcent", "bookman", "utopia", "beraserif",
121 "ccfonts", "chancery", ""
125 char const * tex_fonts_roman_gui[] =
127 N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
128 N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
129 N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
130 N_("Utopia"), N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
135 char const * const tex_fonts_sans[] =
137 "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
141 char const * tex_fonts_sans_gui[] =
143 N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
144 N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
148 char const * const tex_fonts_monospaced[] =
150 "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
154 char const * tex_fonts_monospaced_gui[] =
156 N_("Default"), N_("Computer Modern Typewriter"),
157 N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
158 N_("LuxiMono"), N_("CM Typewriter Light"), ""
162 char const * backref_opts[] =
164 "false", "section", "slide", "page", ""
168 char const * backref_opts_gui[] =
170 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
174 vector<pair<string, QString> > pagestyles;
177 } // anonymous namespace
181 RGBColor set_backgroundcolor;
182 bool is_backgroundcolor;
183 RGBColor set_fontcolor;
185 RGBColor set_notefontcolor;
186 RGBColor set_boxbgcolor;
189 // used when sorting the textclass list.
190 class less_textclass_avail_desc
191 : public binary_function<string, string, int>
194 bool operator()(string const & lhs, string const & rhs) const
196 // Ordering criteria:
197 // 1. Availability of text class
198 // 2. Description (lexicographic)
199 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
200 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
201 int const order = compare_no_case(
202 translateIfPossible(from_utf8(tc1.description())),
203 translateIfPossible(from_utf8(tc2.description())));
204 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
205 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
214 vector<string> getRequiredList(string const & modName)
216 LyXModule const * const mod = theModuleList[modName];
218 return vector<string>(); //empty such thing
219 return mod->getRequiredModules();
223 vector<string> getExcludedList(string const & modName)
225 LyXModule const * const mod = theModuleList[modName];
227 return vector<string>(); //empty such thing
228 return mod->getExcludedModules();
232 docstring getModuleDescription(string const & modName)
234 LyXModule const * const mod = theModuleList[modName];
236 return _("Module not found!");
238 return translateIfPossible(from_utf8(mod->getDescription()));
242 vector<string> getPackageList(string const & modName)
244 LyXModule const * const mod = theModuleList[modName];
246 return vector<string>(); //empty such thing
247 return mod->getPackageList();
251 bool isModuleAvailable(string const & modName)
253 LyXModule const * const mod = theModuleList[modName];
256 return mod->isAvailable();
259 } // anonymous namespace
262 /////////////////////////////////////////////////////////////////////
264 // ModuleSelectionManager
266 /////////////////////////////////////////////////////////////////////
268 /// SelectionManager for use with modules
269 class ModuleSelectionManager : public GuiSelectionManager
273 ModuleSelectionManager(
274 QTreeView * availableLV,
275 QListView * selectedLV,
279 QPushButton * downPB,
280 GuiIdListModel * availableModel,
281 GuiIdListModel * selectedModel,
282 GuiDocument const * container)
283 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
284 upPB, downPB, availableModel, selectedModel), container_(container)
287 void updateProvidedModules(LayoutModuleList const & pm)
288 { provided_modules_ = pm.list(); }
290 void updateExcludedModules(LayoutModuleList const & em)
291 { excluded_modules_ = em.list(); }
294 virtual void updateAddPB();
296 virtual void updateUpPB();
298 virtual void updateDownPB();
300 virtual void updateDelPB();
301 /// returns availableModel as a GuiIdListModel
302 GuiIdListModel * getAvailableModel()
304 return dynamic_cast<GuiIdListModel *>(availableModel);
306 /// returns selectedModel as a GuiIdListModel
307 GuiIdListModel * getSelectedModel()
309 return dynamic_cast<GuiIdListModel *>(selectedModel);
311 /// keeps a list of the modules the text class provides
312 list<string> provided_modules_;
314 list<string> excluded_modules_;
316 GuiDocument const * container_;
319 void ModuleSelectionManager::updateAddPB()
321 int const arows = availableModel->rowCount();
322 QModelIndexList const avail_sels =
323 availableLV->selectionModel()->selectedIndexes();
325 // disable if there aren't any modules (?), if none of them is chosen
326 // in the dialog, or if the chosen one is already selected for use.
327 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
328 addPB->setEnabled(false);
332 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
333 string const modname = getAvailableModel()->getIDString(idx.row());
336 container_->params().moduleCanBeAdded(modname);
337 addPB->setEnabled(enable);
341 void ModuleSelectionManager::updateDownPB()
343 int const srows = selectedModel->rowCount();
345 downPB->setEnabled(false);
348 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
349 int const curRow = curidx.row();
350 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
351 downPB->setEnabled(false);
355 // determine whether immediately succeding element requires this one
356 string const curmodname = getSelectedModel()->getIDString(curRow);
357 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
359 vector<string> reqs = getRequiredList(nextmodname);
361 // if it doesn't require anything....
363 downPB->setEnabled(true);
367 // Enable it if this module isn't required.
368 // FIXME This should perhaps be more flexible and check whether, even
369 // if the next one is required, there is also an earlier one that will do.
371 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
374 void ModuleSelectionManager::updateUpPB()
376 int const srows = selectedModel->rowCount();
378 upPB->setEnabled(false);
382 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
383 int curRow = curIdx.row();
384 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
385 upPB->setEnabled(false);
388 string const curmodname = getSelectedModel()->getIDString(curRow);
390 // determine whether immediately preceding element is required by this one
391 vector<string> reqs = getRequiredList(curmodname);
393 // if this one doesn't require anything....
395 upPB->setEnabled(true);
400 // Enable it if the preceding module isn't required.
401 // NOTE This is less flexible than it might be. We could check whether, even
402 // if the previous one is required, there is an earlier one that would do.
403 string const premod = getSelectedModel()->getIDString(curRow - 1);
404 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
407 void ModuleSelectionManager::updateDelPB()
409 int const srows = selectedModel->rowCount();
411 deletePB->setEnabled(false);
415 QModelIndex const & curidx =
416 selectedLV->selectionModel()->currentIndex();
417 int const curRow = curidx.row();
418 if (curRow < 0 || curRow >= srows) { // invalid index?
419 deletePB->setEnabled(false);
423 string const curmodname = getSelectedModel()->getIDString(curRow);
425 // We're looking here for a reason NOT to enable the button. If we
426 // find one, we disable it and return. If we don't, we'll end up at
427 // the end of the function, and then we enable it.
428 for (int i = curRow + 1; i < srows; ++i) {
429 string const thisMod = getSelectedModel()->getIDString(i);
430 vector<string> reqs = getRequiredList(thisMod);
431 //does this one require us?
432 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
436 // OK, so this module requires us
437 // is there an EARLIER module that also satisfies the require?
438 // NOTE We demand that it be earlier to keep the list of modules
439 // consistent with the rule that a module must be proceeded by a
440 // required module. There would be more flexible ways to proceed,
441 // but that would be a lot more complicated, and the logic here is
442 // already complicated. (That's why I've left the debugging code.)
443 // lyxerr << "Testing " << thisMod << endl;
444 bool foundone = false;
445 for (int j = 0; j < curRow; ++j) {
446 string const mod = getSelectedModel()->getIDString(j);
447 // lyxerr << "In loop: Testing " << mod << endl;
448 // do we satisfy the require?
449 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
450 // lyxerr << mod << " does the trick." << endl;
455 // did we find a module to satisfy the require?
457 // lyxerr << "No matching module found." << endl;
458 deletePB->setEnabled(false);
462 // lyxerr << "All's well that ends well." << endl;
463 deletePB->setEnabled(true);
467 /////////////////////////////////////////////////////////////////////
471 /////////////////////////////////////////////////////////////////////
473 PreambleModule::PreambleModule() : current_id_(0)
475 // This is not a memory leak. The object will be destroyed
477 (void) new LaTeXHighlighter(preambleTE->document());
478 setFocusProxy(preambleTE);
479 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
483 void PreambleModule::update(BufferParams const & params, BufferId id)
485 QString preamble = toqstr(params.preamble);
486 // Nothing to do if the params and preamble are unchanged.
487 if (id == current_id_
488 && preamble == preambleTE->document()->toPlainText())
491 QTextCursor cur = preambleTE->textCursor();
492 // Save the coords before switching to the new one.
493 preamble_coords_[current_id_] =
494 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
496 // Save the params address for further use.
498 preambleTE->document()->setPlainText(preamble);
499 Coords::const_iterator it = preamble_coords_.find(current_id_);
500 if (it == preamble_coords_.end())
501 // First time we open this one.
502 preamble_coords_[current_id_] = make_pair(0, 0);
504 // Restore saved coords.
505 QTextCursor cur = preambleTE->textCursor();
506 cur.setPosition(it->second.first);
507 preambleTE->setTextCursor(cur);
508 preambleTE->verticalScrollBar()->setValue(it->second.second);
513 void PreambleModule::apply(BufferParams & params)
515 params.preamble = fromqstr(preambleTE->document()->toPlainText());
519 void PreambleModule::closeEvent(QCloseEvent * e)
521 // Save the coords before closing.
522 QTextCursor cur = preambleTE->textCursor();
523 preamble_coords_[current_id_] =
524 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
529 /////////////////////////////////////////////////////////////////////
533 /////////////////////////////////////////////////////////////////////
536 LocalLayout::LocalLayout() : current_id_(0), is_valid_(false)
538 connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
539 connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
543 void LocalLayout::update(BufferParams const & params, BufferId id)
545 QString layout = toqstr(params.local_layout);
546 // Nothing to do if the params and preamble are unchanged.
547 if (id == current_id_
548 && layout == locallayoutTE->document()->toPlainText())
551 // Save the params address for further use.
553 locallayoutTE->document()->setPlainText(layout);
558 void LocalLayout::apply(BufferParams & params)
560 string const layout = fromqstr(locallayoutTE->document()->toPlainText());
561 params.local_layout = layout;
565 void LocalLayout::textChanged()
567 static const QString unknown = qt_("Press button to check validity...");
570 infoLB->setText(unknown);
571 validatePB->setEnabled(true);
576 void LocalLayout::validate() {
577 static const QString valid = qt_("Layout is valid!");
578 static const QString vtext =
579 toqstr("<p style=\"font-weight: bold; \">")
580 + valid + toqstr("</p>");
581 static const QString invalid = qt_("Layout is invalid!");
582 static const QString ivtext =
583 toqstr("<p style=\"color: #c00000; font-weight: bold; \">")
584 + invalid + toqstr("</p>");
586 string const layout =
587 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
588 if (layout.empty()) {
592 is_valid_ = TextClass::validate(layout);
593 infoLB->setText(is_valid_ ? vtext : ivtext);
595 validatePB->setEnabled(false);
599 void LocalLayout::validatePressed() {
605 /////////////////////////////////////////////////////////////////////
609 /////////////////////////////////////////////////////////////////////
612 GuiDocument::GuiDocument(GuiView & lv)
613 : GuiDialog(lv, "document", qt_("Document Settings"))
617 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
618 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
619 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
620 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
622 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
623 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
625 // Manage the restore, ok, apply, restore and cancel/close buttons
626 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
628 bc().setApply(applyPB);
629 bc().setCancel(closePB);
630 bc().setRestore(restorePB);
634 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
635 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
636 this, SLOT(change_adaptor()));
637 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
638 this, SLOT(setLSpacing(int)));
639 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
640 this, SLOT(change_adaptor()));
642 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
643 this, SLOT(change_adaptor()));
644 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
645 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
646 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
647 this, SLOT(change_adaptor()));
648 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
649 this, SLOT(setIndent(int)));
650 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
651 this, SLOT(change_adaptor()));
652 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
653 this, SLOT(change_adaptor()));
655 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
656 this, SLOT(change_adaptor()));
657 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
658 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
659 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
660 this, SLOT(change_adaptor()));
661 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
662 this, SLOT(setSkip(int)));
663 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
664 this, SLOT(change_adaptor()));
665 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
666 this, SLOT(change_adaptor()));
668 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
669 this, SLOT(enableIndent(bool)));
670 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
671 this, SLOT(enableSkip(bool)));
673 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
674 this, SLOT(change_adaptor()));
675 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
676 this, SLOT(setColSep()));
678 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
679 textLayoutModule->lspacingLE));
680 textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
681 textLayoutModule->indentLE));
682 textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
683 textLayoutModule->skipLE));
685 textLayoutModule->indentCO->addItem(qt_("Default"));
686 textLayoutModule->indentCO->addItem(qt_("Custom"));
687 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
688 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
689 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
690 textLayoutModule->skipCO->addItem(qt_("Custom"));
691 textLayoutModule->lspacingCO->insertItem(
692 Spacing::Single, qt_("Single"));
693 textLayoutModule->lspacingCO->insertItem(
694 Spacing::Onehalf, qt_("OneHalf"));
695 textLayoutModule->lspacingCO->insertItem(
696 Spacing::Double, qt_("Double"));
697 textLayoutModule->lspacingCO->insertItem(
698 Spacing::Other, qt_("Custom"));
699 // initialize the length validator
700 bc().addCheckedLineEdit(textLayoutModule->indentLE);
701 bc().addCheckedLineEdit(textLayoutModule->skipLE);
704 // master/child handling
705 masterChildModule = new UiWidget<Ui::MasterChildUi>;
707 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
708 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
709 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
710 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
711 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
712 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
713 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
714 this, SLOT(change_adaptor()));
715 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
716 this, SLOT(change_adaptor()));
717 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
718 this, SLOT(change_adaptor()));
719 masterChildModule->childrenTW->setColumnCount(2);
720 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
721 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
722 masterChildModule->childrenTW->resizeColumnToContents(1);
723 masterChildModule->childrenTW->resizeColumnToContents(2);
727 outputModule = new UiWidget<Ui::OutputUi>;
729 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
730 this, SLOT(change_adaptor()));
731 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
732 this, SLOT(change_adaptor()));
733 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
734 this, SLOT(change_adaptor()));
735 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
736 this, SLOT(change_adaptor()));
738 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
739 this, SLOT(change_adaptor()));
740 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
741 this, SLOT(change_adaptor()));
742 outputModule->synccustomCB->addItem("");
743 outputModule->synccustomCB->addItem("\\synctex=1");
744 outputModule->synccustomCB->addItem("\\synctex=-1");
745 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
748 fontModule = new UiWidget<Ui::FontUi>;
749 connect(fontModule->osFontsCB, SIGNAL(clicked()),
750 this, SLOT(change_adaptor()));
751 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
752 this, SLOT(osFontsChanged(bool)));
753 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
754 this, SLOT(change_adaptor()));
755 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
756 this, SLOT(romanChanged(int)));
757 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
758 this, SLOT(change_adaptor()));
759 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
760 this, SLOT(sansChanged(int)));
761 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
762 this, SLOT(change_adaptor()));
763 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
764 this, SLOT(ttChanged(int)));
765 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
766 this, SLOT(change_adaptor()));
767 connect(fontModule->fontencCO, SIGNAL(activated(int)),
768 this, SLOT(change_adaptor()));
769 connect(fontModule->fontencCO, SIGNAL(activated(int)),
770 this, SLOT(fontencChanged(int)));
771 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
772 this, SLOT(change_adaptor()));
773 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
774 this, SLOT(change_adaptor()));
775 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
776 this, SLOT(change_adaptor()));
777 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
778 this, SLOT(change_adaptor()));
779 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
780 this, SLOT(change_adaptor()));
781 connect(fontModule->fontScCB, SIGNAL(clicked()),
782 this, SLOT(change_adaptor()));
783 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
784 this, SLOT(change_adaptor()));
788 fontModule->fontsizeCO->addItem(qt_("Default"));
789 fontModule->fontsizeCO->addItem(qt_("10"));
790 fontModule->fontsizeCO->addItem(qt_("11"));
791 fontModule->fontsizeCO->addItem(qt_("12"));
793 fontModule->fontencCO->addItem(qt_("Default"));
794 fontModule->fontencCO->addItem(qt_("Custom"));
795 fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
797 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
798 fontModule->fontsDefaultCO->addItem(
799 qt_(GuiDocument::fontfamilies_gui[n]));
801 if (!LaTeXFeatures::isAvailable("fontspec"))
802 fontModule->osFontsCB->setToolTip(
803 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
804 "You need to install the package \"fontspec\" to use this feature"));
808 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
809 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
810 this, SLOT(papersizeChanged(int)));
811 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
812 this, SLOT(papersizeChanged(int)));
813 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
814 this, SLOT(change_adaptor()));
815 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
816 this, SLOT(change_adaptor()));
817 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
818 this, SLOT(change_adaptor()));
819 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
820 this, SLOT(change_adaptor()));
821 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
822 this, SLOT(change_adaptor()));
823 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
824 this, SLOT(change_adaptor()));
825 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
826 this, SLOT(change_adaptor()));
827 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
828 this, SLOT(change_adaptor()));
829 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
830 this, SLOT(change_adaptor()));
831 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
832 this, SLOT(change_adaptor()));
834 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
835 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
836 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
837 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
838 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
839 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
840 pageLayoutModule->paperheightL);
841 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
842 pageLayoutModule->paperwidthL);
844 QComboBox * cb = pageLayoutModule->papersizeCO;
845 cb->addItem(qt_("Default"));
846 cb->addItem(qt_("Custom"));
847 cb->addItem(qt_("US letter"));
848 cb->addItem(qt_("US legal"));
849 cb->addItem(qt_("US executive"));
850 cb->addItem(qt_("A0"));
851 cb->addItem(qt_("A1"));
852 cb->addItem(qt_("A2"));
853 cb->addItem(qt_("A3"));
854 cb->addItem(qt_("A4"));
855 cb->addItem(qt_("A5"));
856 cb->addItem(qt_("A6"));
857 cb->addItem(qt_("B0"));
858 cb->addItem(qt_("B1"));
859 cb->addItem(qt_("B2"));
860 cb->addItem(qt_("B3"));
861 cb->addItem(qt_("B4"));
862 cb->addItem(qt_("B5"));
863 cb->addItem(qt_("B6"));
864 cb->addItem(qt_("C0"));
865 cb->addItem(qt_("C1"));
866 cb->addItem(qt_("C2"));
867 cb->addItem(qt_("C3"));
868 cb->addItem(qt_("C4"));
869 cb->addItem(qt_("C5"));
870 cb->addItem(qt_("C6"));
871 cb->addItem(qt_("JIS B0"));
872 cb->addItem(qt_("JIS B1"));
873 cb->addItem(qt_("JIS B2"));
874 cb->addItem(qt_("JIS B3"));
875 cb->addItem(qt_("JIS B4"));
876 cb->addItem(qt_("JIS B5"));
877 cb->addItem(qt_("JIS B6"));
878 // remove the %-items from the unit choice
879 pageLayoutModule->paperwidthUnitCO->noPercents();
880 pageLayoutModule->paperheightUnitCO->noPercents();
881 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
882 pageLayoutModule->paperheightLE));
883 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
884 pageLayoutModule->paperwidthLE));
888 marginsModule = new UiWidget<Ui::MarginsUi>;
889 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
890 this, SLOT(setCustomMargins(bool)));
891 connect(marginsModule->marginCB, SIGNAL(clicked()),
892 this, SLOT(change_adaptor()));
893 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
894 this, SLOT(change_adaptor()));
895 connect(marginsModule->topUnit, SIGNAL(activated(int)),
896 this, SLOT(change_adaptor()));
897 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
898 this, SLOT(change_adaptor()));
899 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
900 this, SLOT(change_adaptor()));
901 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
902 this, SLOT(change_adaptor()));
903 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
904 this, SLOT(change_adaptor()));
905 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
906 this, SLOT(change_adaptor()));
907 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
908 this, SLOT(change_adaptor()));
909 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
910 this, SLOT(change_adaptor()));
911 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
912 this, SLOT(change_adaptor()));
913 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
914 this, SLOT(change_adaptor()));
915 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
916 this, SLOT(change_adaptor()));
917 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
918 this, SLOT(change_adaptor()));
919 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
920 this, SLOT(change_adaptor()));
921 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
922 this, SLOT(change_adaptor()));
923 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
924 this, SLOT(change_adaptor()));
925 marginsModule->topLE->setValidator(unsignedLengthValidator(
926 marginsModule->topLE));
927 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
928 marginsModule->bottomLE));
929 marginsModule->innerLE->setValidator(unsignedLengthValidator(
930 marginsModule->innerLE));
931 marginsModule->outerLE->setValidator(unsignedLengthValidator(
932 marginsModule->outerLE));
933 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
934 marginsModule->headsepLE));
935 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
936 marginsModule->headheightLE));
937 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
938 marginsModule->footskipLE));
939 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
940 marginsModule->columnsepLE));
942 bc().addCheckedLineEdit(marginsModule->topLE,
943 marginsModule->topL);
944 bc().addCheckedLineEdit(marginsModule->bottomLE,
945 marginsModule->bottomL);
946 bc().addCheckedLineEdit(marginsModule->innerLE,
947 marginsModule->innerL);
948 bc().addCheckedLineEdit(marginsModule->outerLE,
949 marginsModule->outerL);
950 bc().addCheckedLineEdit(marginsModule->headsepLE,
951 marginsModule->headsepL);
952 bc().addCheckedLineEdit(marginsModule->headheightLE,
953 marginsModule->headheightL);
954 bc().addCheckedLineEdit(marginsModule->footskipLE,
955 marginsModule->footskipL);
956 bc().addCheckedLineEdit(marginsModule->columnsepLE,
957 marginsModule->columnsepL);
961 langModule = new UiWidget<Ui::LanguageUi>;
962 connect(langModule->languageCO, SIGNAL(activated(int)),
963 this, SLOT(change_adaptor()));
964 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
965 this, SLOT(change_adaptor()));
966 connect(langModule->otherencodingRB, SIGNAL(clicked()),
967 this, SLOT(change_adaptor()));
968 connect(langModule->encodingCO, SIGNAL(activated(int)),
969 this, SLOT(change_adaptor()));
970 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
971 this, SLOT(change_adaptor()));
972 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
973 this, SLOT(change_adaptor()));
974 connect(langModule->languagePackageED, SIGNAL(textChanged(QString)),
975 this, SLOT(change_adaptor()));
976 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
977 this, SLOT(languagePackageChanged(int)));
979 QAbstractItemModel * language_model = guiApp->languageModel();
980 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
981 language_model->sort(0);
982 langModule->languageCO->setModel(language_model);
983 langModule->languageCO->setModelColumn(0);
985 // Always put the default encoding in the first position.
986 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
987 QStringList encodinglist;
988 Encodings::const_iterator it = encodings.begin();
989 Encodings::const_iterator const end = encodings.end();
990 for (; it != end; ++it)
991 encodinglist.append(qt_(it->guiName()));
993 langModule->encodingCO->addItems(encodinglist);
995 langModule->quoteStyleCO->addItem(qt_("``text''"));
996 langModule->quoteStyleCO->addItem(qt_("''text''"));
997 langModule->quoteStyleCO->addItem(qt_(",,text``"));
998 langModule->quoteStyleCO->addItem(qt_(",,text''"));
999 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
1000 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
1002 langModule->languagePackageCO->addItem(
1003 qt_("Default"), toqstr("default"));
1004 langModule->languagePackageCO->addItem(
1005 qt_("Automatic"), toqstr("auto"));
1006 langModule->languagePackageCO->addItem(
1007 qt_("Always Babel"), toqstr("babel"));
1008 langModule->languagePackageCO->addItem(
1009 qt_("Custom"), toqstr("custom"));
1010 langModule->languagePackageCO->addItem(
1011 qt_("None[[language package]]"), toqstr("none"));
1015 colorModule = new UiWidget<Ui::ColorUi>;
1016 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1017 this, SLOT(changeFontColor()));
1018 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1019 this, SLOT(deleteFontColor()));
1020 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1021 this, SLOT(changeNoteFontColor()));
1022 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1023 this, SLOT(deleteNoteFontColor()));
1024 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1025 this, SLOT(changeBackgroundColor()));
1026 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1027 this, SLOT(deleteBackgroundColor()));
1028 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1029 this, SLOT(changeBoxBackgroundColor()));
1030 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1031 this, SLOT(deleteBoxBackgroundColor()));
1035 numberingModule = new UiWidget<Ui::NumberingUi>;
1036 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1037 this, SLOT(change_adaptor()));
1038 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1039 this, SLOT(change_adaptor()));
1040 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1041 this, SLOT(updateNumbering()));
1042 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1043 this, SLOT(updateNumbering()));
1044 numberingModule->tocTW->setColumnCount(3);
1045 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1046 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1047 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1048 numberingModule->tocTW->header()->setResizeMode(QHeaderView::ResizeToContents);
1052 biblioModule = new UiWidget<Ui::BiblioUi>;
1053 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1054 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1055 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1056 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1057 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1058 this, SLOT(change_adaptor()));
1059 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1060 this, SLOT(change_adaptor()));
1061 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1062 this, SLOT(change_adaptor()));
1063 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1064 this, SLOT(change_adaptor()));
1065 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1066 this, SLOT(change_adaptor()));
1067 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1068 this, SLOT(bibtexChanged(int)));
1069 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
1070 this, SLOT(change_adaptor()));
1072 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1073 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1074 biblioModule->citeStyleCO->setCurrentIndex(0);
1076 // NOTE: we do not provide "custom" here for security reasons!
1077 biblioModule->bibtexCO->clear();
1078 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1079 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1080 it != lyxrc.bibtex_alternatives.end(); ++it) {
1081 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1082 biblioModule->bibtexCO->addItem(command, command);
1087 indicesModule = new GuiIndices;
1088 connect(indicesModule, SIGNAL(changed()),
1089 this, SLOT(change_adaptor()));
1093 mathsModule = new UiWidget<Ui::MathsUi>;
1094 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1095 mathsModule->amsCB, SLOT(setDisabled(bool)));
1096 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1097 mathsModule->esintCB, SLOT(setDisabled(bool)));
1098 connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1099 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1100 connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1101 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1103 connect(mathsModule->amsCB, SIGNAL(clicked()),
1104 this, SLOT(change_adaptor()));
1105 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1106 this, SLOT(change_adaptor()));
1107 connect(mathsModule->esintCB, SIGNAL(clicked()),
1108 this, SLOT(change_adaptor()));
1109 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1110 this, SLOT(change_adaptor()));
1111 connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1112 this, SLOT(change_adaptor()));
1113 connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1114 this, SLOT(change_adaptor()));
1115 connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1116 this, SLOT(change_adaptor()));
1117 connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1118 this, SLOT(change_adaptor()));
1122 latexModule = new UiWidget<Ui::LaTeXUi>;
1123 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1124 this, SLOT(change_adaptor()));
1125 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1126 this, SLOT(change_adaptor()));
1127 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1128 this, SLOT(change_adaptor()));
1129 connect(latexModule->classCO, SIGNAL(activated(int)),
1130 this, SLOT(classChanged()));
1131 connect(latexModule->classCO, SIGNAL(activated(int)),
1132 this, SLOT(change_adaptor()));
1133 connect(latexModule->layoutPB, SIGNAL(clicked()),
1134 this, SLOT(browseLayout()));
1135 connect(latexModule->layoutPB, SIGNAL(clicked()),
1136 this, SLOT(change_adaptor()));
1137 connect(latexModule->childDocGB, SIGNAL(clicked()),
1138 this, SLOT(change_adaptor()));
1139 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1140 this, SLOT(change_adaptor()));
1141 connect(latexModule->childDocPB, SIGNAL(clicked()),
1142 this, SLOT(browseMaster()));
1143 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1144 this, SLOT(change_adaptor()));
1145 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1146 this, SLOT(change_adaptor()));
1148 // postscript drivers
1149 for (int n = 0; tex_graphics[n][0]; ++n) {
1150 QString enc = qt_(tex_graphics_gui[n]);
1151 latexModule->psdriverCO->addItem(enc);
1154 latexModule->classCO->setModel(&classes_model_);
1155 LayoutFileList const & bcl = LayoutFileList::get();
1156 vector<LayoutFileIndex> classList = bcl.classList();
1157 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1159 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1160 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1161 for (int i = 0; cit != cen; ++cit, ++i) {
1162 LayoutFile const & tc = bcl[*cit];
1163 docstring item = (tc.isTeXClassAvailable()) ?
1164 from_utf8(tc.description()) :
1165 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1166 classes_model_.insertRow(i, toqstr(item), *cit);
1171 branchesModule = new GuiBranches;
1172 connect(branchesModule, SIGNAL(changed()),
1173 this, SLOT(change_adaptor()));
1174 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1175 this, SLOT(branchesRename(docstring const &, docstring const &)));
1176 updateUnknownBranches();
1180 preambleModule = new PreambleModule;
1181 connect(preambleModule, SIGNAL(changed()),
1182 this, SLOT(change_adaptor()));
1184 localLayout = new LocalLayout;
1185 connect(localLayout, SIGNAL(changed()),
1186 this, SLOT(change_adaptor()));
1190 bulletsModule = new BulletsModule;
1191 connect(bulletsModule, SIGNAL(changed()),
1192 this, SLOT(change_adaptor()));
1196 modulesModule = new UiWidget<Ui::ModulesUi>;
1197 modulesModule->availableLV->header()->setVisible(false);
1198 modulesModule->availableLV->header()->setResizeMode(QHeaderView::ResizeToContents);
1199 modulesModule->availableLV->header()->setStretchLastSection(false);
1201 new ModuleSelectionManager(modulesModule->availableLV,
1202 modulesModule->selectedLV,
1203 modulesModule->addPB, modulesModule->deletePB,
1204 modulesModule->upPB, modulesModule->downPB,
1205 availableModel(), selectedModel(), this);
1206 connect(selectionManager, SIGNAL(updateHook()),
1207 this, SLOT(updateModuleInfo()));
1208 connect(selectionManager, SIGNAL(updateHook()),
1209 this, SLOT(change_adaptor()));
1210 connect(selectionManager, SIGNAL(selectionChanged()),
1211 this, SLOT(modulesChanged()));
1215 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1216 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1217 this, SLOT(change_adaptor()));
1218 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1219 this, SLOT(change_adaptor()));
1220 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1221 this, SLOT(change_adaptor()));
1222 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1223 this, SLOT(change_adaptor()));
1224 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1225 this, SLOT(change_adaptor()));
1226 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1227 this, SLOT(change_adaptor()));
1228 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1229 this, SLOT(change_adaptor()));
1230 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1231 this, SLOT(change_adaptor()));
1232 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1233 this, SLOT(change_adaptor()));
1234 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1235 this, SLOT(change_adaptor()));
1236 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1237 this, SLOT(change_adaptor()));
1238 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1239 this, SLOT(change_adaptor()));
1240 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1241 this, SLOT(change_adaptor()));
1242 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1243 this, SLOT(change_adaptor()));
1244 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1245 this, SLOT(change_adaptor()));
1246 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1247 this, SLOT(change_adaptor()));
1249 for (int i = 0; backref_opts[i][0]; ++i)
1250 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1254 floatModule = new FloatPlacement;
1255 connect(floatModule, SIGNAL(changed()),
1256 this, SLOT(change_adaptor()));
1260 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1261 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1262 this, SLOT(change_adaptor()));
1263 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1264 this, SLOT(change_adaptor()));
1265 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1266 this, SLOT(setListingsMessage()));
1267 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1268 this, SLOT(setListingsMessage()));
1269 listingsModule->listingsTB->setPlainText(
1270 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1274 docPS->addPanel(latexModule, qt_("Document Class"));
1275 docPS->addPanel(masterChildModule, qt_("Child Documents"));
1276 docPS->addPanel(modulesModule, qt_("Modules"));
1277 docPS->addPanel(localLayout, qt_("Local Layout"));
1278 docPS->addPanel(fontModule, qt_("Fonts"));
1279 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1280 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1281 docPS->addPanel(marginsModule, qt_("Page Margins"));
1282 docPS->addPanel(langModule, qt_("Language"));
1283 docPS->addPanel(colorModule, qt_("Colors"));
1284 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1285 docPS->addPanel(biblioModule, qt_("Bibliography"));
1286 docPS->addPanel(indicesModule, qt_("Indexes"));
1287 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1288 docPS->addPanel(mathsModule, qt_("Math Options"));
1289 docPS->addPanel(floatModule, qt_("Float Placement"));
1290 docPS->addPanel(listingsModule, qt_("Listings"));
1291 docPS->addPanel(bulletsModule, qt_("Bullets"));
1292 docPS->addPanel(branchesModule, qt_("Branches"));
1293 docPS->addPanel(outputModule, qt_("Output"));
1294 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1295 docPS->setCurrentPanel(qt_("Document Class"));
1296 // FIXME: hack to work around resizing bug in Qt >= 4.2
1297 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1298 #if QT_VERSION >= 0x040200
1299 docPS->updateGeometry();
1304 void GuiDocument::saveDefaultClicked()
1310 void GuiDocument::useDefaultsClicked()
1316 void GuiDocument::change_adaptor()
1322 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1327 string child = fromqstr(item->text(0));
1331 if (std::find(includeonlys_.begin(),
1332 includeonlys_.end(), child) != includeonlys_.end())
1333 includeonlys_.remove(child);
1335 includeonlys_.push_back(child);
1337 updateIncludeonlys();
1342 QString GuiDocument::validateListingsParameters()
1344 // use a cache here to avoid repeated validation
1345 // of the same parameters
1346 static string param_cache;
1347 static QString msg_cache;
1349 if (listingsModule->bypassCB->isChecked())
1352 string params = fromqstr(listingsModule->listingsED->toPlainText());
1353 if (params != param_cache) {
1354 param_cache = params;
1355 msg_cache = toqstr(InsetListingsParams(params).validate());
1361 void GuiDocument::setListingsMessage()
1363 static bool isOK = true;
1364 QString msg = validateListingsParameters();
1365 if (msg.isEmpty()) {
1369 // listingsTB->setTextColor("black");
1370 listingsModule->listingsTB->setPlainText(
1371 qt_("Input listings parameters below. "
1372 "Enter ? for a list of parameters."));
1375 // listingsTB->setTextColor("red");
1376 listingsModule->listingsTB->setPlainText(msg);
1381 void GuiDocument::setLSpacing(int item)
1383 textLayoutModule->lspacingLE->setEnabled(item == 3);
1387 void GuiDocument::setIndent(int item)
1389 bool const enable = (item == 1);
1390 textLayoutModule->indentLE->setEnabled(enable);
1391 textLayoutModule->indentLengthCO->setEnabled(enable);
1392 textLayoutModule->skipLE->setEnabled(false);
1393 textLayoutModule->skipLengthCO->setEnabled(false);
1398 void GuiDocument::enableIndent(bool indent)
1400 textLayoutModule->skipLE->setEnabled(!indent);
1401 textLayoutModule->skipLengthCO->setEnabled(!indent);
1403 setIndent(textLayoutModule->indentCO->currentIndex());
1407 void GuiDocument::setSkip(int item)
1409 bool const enable = (item == 3);
1410 textLayoutModule->skipLE->setEnabled(enable);
1411 textLayoutModule->skipLengthCO->setEnabled(enable);
1416 void GuiDocument::enableSkip(bool skip)
1418 textLayoutModule->indentLE->setEnabled(!skip);
1419 textLayoutModule->indentLengthCO->setEnabled(!skip);
1421 setSkip(textLayoutModule->skipCO->currentIndex());
1425 void GuiDocument::setMargins()
1427 bool const extern_geometry =
1428 documentClass().provides("geometry");
1429 marginsModule->marginCB->setEnabled(!extern_geometry);
1430 if (extern_geometry) {
1431 marginsModule->marginCB->setChecked(false);
1432 setCustomMargins(true);
1434 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1435 setCustomMargins(!bp_.use_geometry);
1440 void GuiDocument::papersizeChanged(int paper_size)
1442 setCustomPapersize(paper_size == 1);
1446 void GuiDocument::setCustomPapersize(bool custom)
1448 pageLayoutModule->paperwidthL->setEnabled(custom);
1449 pageLayoutModule->paperwidthLE->setEnabled(custom);
1450 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1451 pageLayoutModule->paperheightL->setEnabled(custom);
1452 pageLayoutModule->paperheightLE->setEnabled(custom);
1453 pageLayoutModule->paperheightLE->setFocus();
1454 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1458 void GuiDocument::setColSep()
1460 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1464 void GuiDocument::setCustomMargins(bool custom)
1466 marginsModule->topL->setEnabled(!custom);
1467 marginsModule->topLE->setEnabled(!custom);
1468 marginsModule->topUnit->setEnabled(!custom);
1470 marginsModule->bottomL->setEnabled(!custom);
1471 marginsModule->bottomLE->setEnabled(!custom);
1472 marginsModule->bottomUnit->setEnabled(!custom);
1474 marginsModule->innerL->setEnabled(!custom);
1475 marginsModule->innerLE->setEnabled(!custom);
1476 marginsModule->innerUnit->setEnabled(!custom);
1478 marginsModule->outerL->setEnabled(!custom);
1479 marginsModule->outerLE->setEnabled(!custom);
1480 marginsModule->outerUnit->setEnabled(!custom);
1482 marginsModule->headheightL->setEnabled(!custom);
1483 marginsModule->headheightLE->setEnabled(!custom);
1484 marginsModule->headheightUnit->setEnabled(!custom);
1486 marginsModule->headsepL->setEnabled(!custom);
1487 marginsModule->headsepLE->setEnabled(!custom);
1488 marginsModule->headsepUnit->setEnabled(!custom);
1490 marginsModule->footskipL->setEnabled(!custom);
1491 marginsModule->footskipLE->setEnabled(!custom);
1492 marginsModule->footskipUnit->setEnabled(!custom);
1494 bool const enableColSep = !custom &&
1495 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1496 marginsModule->columnsepL->setEnabled(enableColSep);
1497 marginsModule->columnsepLE->setEnabled(enableColSep);
1498 marginsModule->columnsepUnit->setEnabled(enableColSep);
1502 void GuiDocument::changeBackgroundColor()
1504 QColor const & newColor = QColorDialog::getColor(
1505 rgb2qcolor(set_backgroundcolor), asQWidget());
1506 if (!newColor.isValid())
1508 // set the button color and text
1509 colorModule->backgroundPB->setStyleSheet(
1510 colorButtonStyleSheet(newColor));
1511 colorModule->backgroundPB->setText(toqstr("Change..."));
1513 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1514 is_backgroundcolor = true;
1519 void GuiDocument::deleteBackgroundColor()
1521 // set the button color back to default by setting an epmty StyleSheet
1522 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1523 // change button text
1524 colorModule->backgroundPB->setText(toqstr("Default..."));
1525 // save default color (white)
1526 set_backgroundcolor = rgbFromHexName("#ffffff");
1527 is_backgroundcolor = false;
1532 void GuiDocument::changeFontColor()
1534 QColor const & newColor = QColorDialog::getColor(
1535 rgb2qcolor(set_fontcolor), asQWidget());
1536 if (!newColor.isValid())
1538 // set the button color and text
1539 colorModule->fontColorPB->setStyleSheet(
1540 colorButtonStyleSheet(newColor));
1541 colorModule->fontColorPB->setText(toqstr("Change..."));
1543 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1544 is_fontcolor = true;
1549 void GuiDocument::deleteFontColor()
1551 // set the button color back to default by setting an epmty StyleSheet
1552 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1553 // change button text
1554 colorModule->fontColorPB->setText(toqstr("Default..."));
1555 // save default color (black)
1556 set_fontcolor = rgbFromHexName("#000000");
1557 is_fontcolor = false;
1562 void GuiDocument::changeNoteFontColor()
1564 QColor const & newColor = QColorDialog::getColor(
1565 rgb2qcolor(set_notefontcolor), asQWidget());
1566 if (!newColor.isValid())
1568 // set the button color
1569 colorModule->noteFontColorPB->setStyleSheet(
1570 colorButtonStyleSheet(newColor));
1572 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1577 void GuiDocument::deleteNoteFontColor()
1579 // set the button color back to light gray
1580 colorModule->noteFontColorPB->setStyleSheet(
1581 colorButtonStyleSheet(QColor(204, 204, 204, 255)));
1582 // save light gray as the set color
1583 set_notefontcolor = rgbFromHexName("#cccccc");
1588 void GuiDocument::changeBoxBackgroundColor()
1590 QColor const & newColor = QColorDialog::getColor(
1591 rgb2qcolor(set_boxbgcolor), asQWidget());
1592 if (!newColor.isValid())
1594 // set the button color
1595 colorModule->boxBackgroundPB->setStyleSheet(
1596 colorButtonStyleSheet(newColor));
1598 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1603 void GuiDocument::deleteBoxBackgroundColor()
1605 // set the button color back to red
1606 colorModule->boxBackgroundPB->setStyleSheet(
1607 colorButtonStyleSheet(QColor(Qt::red)));
1608 // save red as the set color
1609 set_boxbgcolor = rgbFromHexName("#ff0000");
1614 void GuiDocument::osFontsChanged(bool nontexfonts)
1616 bool const tex_fonts = !nontexfonts;
1618 updateDefaultFormat();
1619 langModule->encodingCO->setEnabled(tex_fonts &&
1620 !langModule->defaultencodingRB->isChecked());
1621 langModule->defaultencodingRB->setEnabled(tex_fonts);
1622 langModule->otherencodingRB->setEnabled(tex_fonts);
1624 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1625 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1626 fontModule->cjkFontLE->setEnabled(tex_fonts);
1627 fontModule->cjkFontLA->setEnabled(tex_fonts);
1630 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1631 bool scaleable = providesScale(font);
1632 fontModule->scaleSansSB->setEnabled(scaleable);
1633 fontModule->scaleSansLA->setEnabled(scaleable);
1635 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1636 scaleable = providesScale(font);
1637 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1638 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1640 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1641 fontModule->fontScCB->setEnabled(providesSC(font));
1642 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1644 fontModule->fontencLA->setEnabled(tex_fonts);
1645 fontModule->fontencCO->setEnabled(tex_fonts);
1647 fontModule->fontencLE->setEnabled(false);
1649 fontencChanged(fontModule->fontencCO->currentIndex());
1653 void GuiDocument::updateFontsize(string const & items, string const & sel)
1655 fontModule->fontsizeCO->clear();
1656 fontModule->fontsizeCO->addItem(qt_("Default"));
1658 for (int n = 0; !token(items,'|',n).empty(); ++n)
1659 fontModule->fontsizeCO->
1660 addItem(toqstr(token(items,'|',n)));
1662 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1663 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1664 fontModule->fontsizeCO->setCurrentIndex(n);
1671 void GuiDocument::updateFontlist()
1673 fontModule->fontsRomanCO->clear();
1674 fontModule->fontsSansCO->clear();
1675 fontModule->fontsTypewriterCO->clear();
1677 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1678 if (fontModule->osFontsCB->isChecked()) {
1679 fontModule->fontsRomanCO->addItem(qt_("Default"));
1680 fontModule->fontsSansCO->addItem(qt_("Default"));
1681 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1683 QFontDatabase fontdb;
1684 QStringList families(fontdb.families());
1685 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1686 fontModule->fontsRomanCO->addItem(*it);
1687 fontModule->fontsSansCO->addItem(*it);
1688 fontModule->fontsTypewriterCO->addItem(*it);
1693 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1694 QString font = qt_(tex_fonts_roman_gui[n]);
1695 if (!isFontAvailable(tex_fonts_roman[n]))
1696 font += qt_(" (not installed)");
1697 fontModule->fontsRomanCO->addItem(font);
1699 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1700 QString font = qt_(tex_fonts_sans_gui[n]);
1701 if (!isFontAvailable(tex_fonts_sans[n]))
1702 font += qt_(" (not installed)");
1703 fontModule->fontsSansCO->addItem(font);
1705 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1706 QString font = qt_(tex_fonts_monospaced_gui[n]);
1707 if (!isFontAvailable(tex_fonts_monospaced[n]))
1708 font += qt_(" (not installed)");
1709 fontModule->fontsTypewriterCO->addItem(font);
1714 void GuiDocument::fontencChanged(int item)
1716 fontModule->fontencLE->setEnabled(item == 1);
1720 void GuiDocument::romanChanged(int item)
1722 if (fontModule->osFontsCB->isChecked())
1724 string const font = tex_fonts_roman[item];
1725 fontModule->fontScCB->setEnabled(providesSC(font));
1726 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1730 void GuiDocument::sansChanged(int item)
1732 if (fontModule->osFontsCB->isChecked())
1734 string const font = tex_fonts_sans[item];
1735 bool scaleable = providesScale(font);
1736 fontModule->scaleSansSB->setEnabled(scaleable);
1737 fontModule->scaleSansLA->setEnabled(scaleable);
1741 void GuiDocument::ttChanged(int item)
1743 if (fontModule->osFontsCB->isChecked())
1745 string const font = tex_fonts_monospaced[item];
1746 bool scaleable = providesScale(font);
1747 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1748 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1752 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1755 pageLayoutModule->pagestyleCO->clear();
1756 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1758 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1759 string style = token(items, '|', n);
1760 QString style_gui = qt_(style);
1761 pagestyles.push_back(pair<string, QString>(style, style_gui));
1762 pageLayoutModule->pagestyleCO->addItem(style_gui);
1765 if (sel == "default") {
1766 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1772 for (size_t i = 0; i < pagestyles.size(); ++i)
1773 if (pagestyles[i].first == sel)
1774 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1777 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1781 void GuiDocument::browseLayout()
1783 QString const label1 = qt_("Layouts|#o#O");
1784 QString const dir1 = toqstr(lyxrc.document_path);
1785 QStringList const filter(qt_("LyX Layout (*.layout)"));
1786 QString file = browseRelFile(QString(), bufferFilePath(),
1787 qt_("Local layout file"), filter, false,
1790 if (!file.endsWith(".layout"))
1793 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1794 fromqstr(bufferFilePath()));
1796 int const ret = Alert::prompt(_("Local layout file"),
1797 _("The layout file you have selected is a local layout\n"
1798 "file, not one in the system or user directory. Your\n"
1799 "document may not work with this layout if you do not\n"
1800 "keep the layout file in the document directory."),
1801 1, 1, _("&Set Layout"), _("&Cancel"));
1805 // load the layout file
1806 LayoutFileList & bcl = LayoutFileList::get();
1807 string classname = layoutFile.onlyFileName();
1808 // this will update an existing layout if that layout has been loaded before.
1809 LayoutFileIndex name = bcl.addLocalLayout(
1810 classname.substr(0, classname.size() - 7),
1811 layoutFile.onlyPath().absFileName());
1814 Alert::error(_("Error"),
1815 _("Unable to read local layout file."));
1819 // do not trigger classChanged if there is no change.
1820 if (latexModule->classCO->currentText() == toqstr(name))
1824 int idx = latexModule->classCO->findText(toqstr(name));
1826 classes_model_.insertRow(0, toqstr(name), name);
1827 latexModule->classCO->setCurrentIndex(0);
1829 latexModule->classCO->setCurrentIndex(idx);
1835 void GuiDocument::browseMaster()
1837 QString const title = qt_("Select master document");
1838 QString const dir1 = toqstr(lyxrc.document_path);
1839 QString const old = latexModule->childDocLE->text();
1840 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1841 QStringList const filter(qt_("LyX Files (*.lyx)"));
1842 QString file = browseRelFile(old, docpath, title, filter, false,
1843 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1845 if (!file.isEmpty())
1846 latexModule->childDocLE->setText(file);
1850 void GuiDocument::classChanged()
1852 int idx = latexModule->classCO->currentIndex();
1855 string const classname = classes_model_.getIDString(idx);
1857 // check whether the selected modules have changed.
1858 bool modules_changed = false;
1859 unsigned int const srows = selectedModel()->rowCount();
1860 if (srows != bp_.getModules().size())
1861 modules_changed = true;
1863 list<string>::const_iterator mit = bp_.getModules().begin();
1864 list<string>::const_iterator men = bp_.getModules().end();
1865 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1866 if (selectedModel()->getIDString(i) != *mit) {
1867 modules_changed = true;
1872 if (modules_changed || lyxrc.auto_reset_options) {
1873 if (applyPB->isEnabled()) {
1874 int const ret = Alert::prompt(_("Unapplied changes"),
1875 _("Some changes in the dialog were not yet applied.\n"
1876 "If you do not apply now, they will be lost after this action."),
1877 1, 1, _("&Apply"), _("&Dismiss"));
1883 // We load the TextClass as soon as it is selected. This is
1884 // necessary so that other options in the dialog can be updated
1885 // according to the new class. Note, however, that, if you use
1886 // the scroll wheel when sitting on the combo box, we'll load a
1887 // lot of TextClass objects very quickly....
1888 if (!bp_.setBaseClass(classname)) {
1889 Alert::error(_("Error"), _("Unable to set document class."));
1892 if (lyxrc.auto_reset_options)
1893 bp_.useClassDefaults();
1895 // With the introduction of modules came a distinction between the base
1896 // class and the document class. The former corresponds to the main layout
1897 // file; the latter is that plus the modules (or the document-specific layout,
1898 // or whatever else there could be). Our parameters come from the document
1899 // class. So when we set the base class, we also need to recreate the document
1900 // class. Otherwise, we still have the old one.
1901 bp_.makeDocumentClass();
1906 void GuiDocument::languagePackageChanged(int i)
1908 langModule->languagePackageED->setEnabled(
1909 langModule->languagePackageCO->itemData(i).toString() == "custom");
1913 void GuiDocument::bibtexChanged(int n)
1915 biblioModule->bibtexOptionsED->setEnabled(
1916 biblioModule->bibtexCO->itemData(n).toString() != "default");
1923 // both of these should take a vector<docstring>
1925 // This is an insanely complicated attempt to make this sort of thing
1926 // work with RTL languages.
1927 docstring formatStrVec(vector<string> const & v, docstring const & s)
1929 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1933 return translateIfPossible(from_utf8(v[0]));
1934 if (v.size() == 2) {
1935 docstring retval = _("%1$s and %2$s");
1936 retval = subst(retval, _("and"), s);
1937 return bformat(retval, translateIfPossible(from_utf8(v[0])),
1938 translateIfPossible(from_utf8(v[1])));
1940 // The idea here is to format all but the last two items...
1941 int const vSize = v.size();
1942 docstring t2 = _("%1$s, %2$s");
1943 docstring retval = translateIfPossible(from_utf8(v[0]));
1944 for (int i = 1; i < vSize - 2; ++i)
1945 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
1946 //...and then to plug them, and the last two, into this schema
1947 docstring t = _("%1$s, %2$s, and %3$s");
1948 t = subst(t, _("and"), s);
1949 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
1950 translateIfPossible(from_utf8(v[vSize - 1])));
1953 vector<string> idsToNames(vector<string> const & idList)
1955 vector<string> retval;
1956 vector<string>::const_iterator it = idList.begin();
1957 vector<string>::const_iterator end = idList.end();
1958 for (; it != end; ++it) {
1959 LyXModule const * const mod = theModuleList[*it];
1961 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
1962 translateIfPossible(from_utf8(*it)))));
1964 retval.push_back(mod->getName());
1968 } // end anonymous namespace
1971 void GuiDocument::modulesToParams(BufferParams & bp)
1973 // update list of loaded modules
1974 bp.clearLayoutModules();
1975 int const srows = modules_sel_model_.rowCount();
1976 for (int i = 0; i < srows; ++i)
1977 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1979 // update the list of removed modules
1980 bp.clearRemovedModules();
1981 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1982 list<string>::const_iterator rit = reqmods.begin();
1983 list<string>::const_iterator ren = reqmods.end();
1985 // check each of the default modules
1986 for (; rit != ren; rit++) {
1987 list<string>::const_iterator mit = bp.getModules().begin();
1988 list<string>::const_iterator men = bp.getModules().end();
1990 for (; mit != men; mit++) {
1997 // the module isn't present so must have been removed by the user
1998 bp.addRemovedModule(*rit);
2003 void GuiDocument::modulesChanged()
2005 modulesToParams(bp_);
2006 bp_.makeDocumentClass();
2011 void GuiDocument::updateModuleInfo()
2013 selectionManager->update();
2015 //Module description
2016 bool const focus_on_selected = selectionManager->selectedFocused();
2017 QAbstractItemView * lv;
2018 if (focus_on_selected)
2019 lv = modulesModule->selectedLV;
2021 lv= modulesModule->availableLV;
2022 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2023 modulesModule->infoML->document()->clear();
2026 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2027 GuiIdListModel const & id_model =
2028 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2029 string const modName = id_model.getIDString(idx.row());
2030 docstring desc = getModuleDescription(modName);
2032 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2033 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2036 desc += _("Module provided by document class.");
2039 vector<string> pkglist = getPackageList(modName);
2040 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2041 if (!pkgdesc.empty()) {
2044 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2047 pkglist = getRequiredList(modName);
2048 if (!pkglist.empty()) {
2049 vector<string> const reqdescs = idsToNames(pkglist);
2050 pkgdesc = formatStrVec(reqdescs, _("or"));
2053 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2056 pkglist = getExcludedList(modName);
2057 if (!pkglist.empty()) {
2058 vector<string> const reqdescs = idsToNames(pkglist);
2059 pkgdesc = formatStrVec(reqdescs, _( "and"));
2062 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2065 if (!isModuleAvailable(modName)) {
2068 desc += _("WARNING: Some required packages are unavailable!");
2071 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2075 void GuiDocument::updateNumbering()
2077 DocumentClass const & tclass = documentClass();
2079 numberingModule->tocTW->setUpdatesEnabled(false);
2080 numberingModule->tocTW->clear();
2082 int const depth = numberingModule->depthSL->value();
2083 int const toc = numberingModule->tocSL->value();
2084 QString const no = qt_("No");
2085 QString const yes = qt_("Yes");
2086 QTreeWidgetItem * item = 0;
2088 DocumentClass::const_iterator lit = tclass.begin();
2089 DocumentClass::const_iterator len = tclass.end();
2090 for (; lit != len; ++lit) {
2091 int const toclevel = lit->toclevel;
2092 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2093 item = new QTreeWidgetItem(numberingModule->tocTW);
2094 item->setText(0, toqstr(translateIfPossible(lit->name())));
2095 item->setText(1, (toclevel <= depth) ? yes : no);
2096 item->setText(2, (toclevel <= toc) ? yes : no);
2100 numberingModule->tocTW->setUpdatesEnabled(true);
2101 numberingModule->tocTW->update();
2105 void GuiDocument::updateDefaultFormat()
2109 // make a copy in order to consider unapplied changes
2110 Buffer * tmpbuf = buffer().clone();
2111 tmpbuf->params().useNonTeXFonts =
2112 fontModule->osFontsCB->isChecked();
2113 int idx = latexModule->classCO->currentIndex();
2115 string const classname = classes_model_.getIDString(idx);
2116 tmpbuf->params().setBaseClass(classname);
2117 tmpbuf->params().makeDocumentClass();
2119 outputModule->defaultFormatCO->blockSignals(true);
2120 outputModule->defaultFormatCO->clear();
2121 outputModule->defaultFormatCO->addItem(qt_("Default"),
2122 QVariant(QString("default")));
2123 typedef vector<Format const *> Formats;
2124 Formats formats = tmpbuf->exportableFormats(true);
2125 Formats::const_iterator cit = formats.begin();
2126 Formats::const_iterator end = formats.end();
2127 for (; cit != end; ++cit)
2128 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2129 QVariant(toqstr((*cit)->name())));
2130 outputModule->defaultFormatCO->blockSignals(false);
2136 bool GuiDocument::isChildIncluded(string const & child)
2138 if (includeonlys_.empty())
2140 return (std::find(includeonlys_.begin(),
2141 includeonlys_.end(), child) != includeonlys_.end());
2145 void GuiDocument::applyView()
2148 preambleModule->apply(bp_);
2149 localLayout->apply(bp_);
2152 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2153 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2156 bp_.setCiteEngine(ENGINE_BASIC);
2158 if (biblioModule->citeNatbibRB->isChecked()) {
2159 bool const use_numerical_citations =
2160 biblioModule->citeStyleCO->currentIndex();
2161 if (use_numerical_citations)
2162 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2164 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2166 } else if (biblioModule->citeJurabibRB->isChecked())
2167 bp_.setCiteEngine(ENGINE_JURABIB);
2170 biblioModule->bibtopicCB->isChecked();
2172 string const bibtex_command =
2173 fromqstr(biblioModule->bibtexCO->itemData(
2174 biblioModule->bibtexCO->currentIndex()).toString());
2175 string const bibtex_options =
2176 fromqstr(biblioModule->bibtexOptionsED->text());
2177 if (bibtex_command == "default" || bibtex_options.empty())
2178 bp_.bibtex_command = bibtex_command;
2180 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2183 indicesModule->apply(bp_);
2185 // language & quotes
2186 if (langModule->defaultencodingRB->isChecked()) {
2187 bp_.inputenc = "auto";
2189 int i = langModule->encodingCO->currentIndex();
2191 bp_.inputenc = "default";
2193 QString const enc_gui =
2194 langModule->encodingCO->currentText();
2195 Encodings::const_iterator it = encodings.begin();
2196 Encodings::const_iterator const end = encodings.end();
2198 for (; it != end; ++it) {
2199 if (qt_(it->guiName()) == enc_gui) {
2200 bp_.inputenc = it->latexName();
2206 // should not happen
2207 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2208 bp_.inputenc = "default";
2213 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2214 switch (langModule->quoteStyleCO->currentIndex()) {
2216 lga = InsetQuotes::EnglishQuotes;
2219 lga = InsetQuotes::SwedishQuotes;
2222 lga = InsetQuotes::GermanQuotes;
2225 lga = InsetQuotes::PolishQuotes;
2228 lga = InsetQuotes::FrenchQuotes;
2231 lga = InsetQuotes::DanishQuotes;
2234 bp_.quotes_language = lga;
2236 QString const lang = langModule->languageCO->itemData(
2237 langModule->languageCO->currentIndex()).toString();
2238 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2240 QString const pack = langModule->languagePackageCO->itemData(
2241 langModule->languagePackageCO->currentIndex()).toString();
2242 if (pack == "custom")
2244 fromqstr(langModule->languagePackageED->text());
2246 bp_.lang_package = fromqstr(pack);
2249 bp_.backgroundcolor = set_backgroundcolor;
2250 bp_.isbackgroundcolor = is_backgroundcolor;
2251 bp_.fontcolor = set_fontcolor;
2252 bp_.isfontcolor = is_fontcolor;
2253 bp_.notefontcolor = set_notefontcolor;
2254 bp_.boxbgcolor = set_boxbgcolor;
2257 if (bp_.documentClass().hasTocLevels()) {
2258 bp_.tocdepth = numberingModule->tocSL->value();
2259 bp_.secnumdepth = numberingModule->depthSL->value();
2263 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2264 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2265 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2266 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2269 bp_.graphics_driver =
2270 tex_graphics[latexModule->psdriverCO->currentIndex()];
2273 int idx = latexModule->classCO->currentIndex();
2275 string const classname = classes_model_.getIDString(idx);
2276 bp_.setBaseClass(classname);
2280 modulesToParams(bp_);
2283 if (mathsModule->amsautoCB->isChecked())
2284 bp_.use_amsmath = BufferParams::package_auto;
2286 if (mathsModule->amsCB->isChecked())
2287 bp_.use_amsmath = BufferParams::package_on;
2289 bp_.use_amsmath = BufferParams::package_off;
2291 if (mathsModule->esintautoCB->isChecked())
2292 bp_.use_esint = BufferParams::package_auto;
2294 if (mathsModule->esintCB->isChecked())
2295 bp_.use_esint = BufferParams::package_on;
2297 bp_.use_esint = BufferParams::package_off;
2299 if (mathsModule->mhchemautoCB->isChecked())
2300 bp_.use_mhchem = BufferParams::package_auto;
2302 if (mathsModule->mhchemCB->isChecked())
2303 bp_.use_mhchem = BufferParams::package_on;
2305 bp_.use_mhchem = BufferParams::package_off;
2307 if (mathsModule->mathdotsautoCB->isChecked())
2308 bp_.use_mathdots = BufferParams::package_auto;
2310 if (mathsModule->mathdotsCB->isChecked())
2311 bp_.use_mathdots = BufferParams::package_on;
2313 bp_.use_mathdots = BufferParams::package_off;
2317 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2318 bp_.pagestyle = "default";
2320 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2321 for (size_t i = 0; i != pagestyles.size(); ++i)
2322 if (pagestyles[i].second == style_gui)
2323 bp_.pagestyle = pagestyles[i].first;
2327 switch (textLayoutModule->lspacingCO->currentIndex()) {
2329 bp_.spacing().set(Spacing::Single);
2332 bp_.spacing().set(Spacing::Onehalf);
2335 bp_.spacing().set(Spacing::Double);
2338 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2340 bp_.spacing().set(Spacing::Single);
2342 bp_.spacing().set(Spacing::Other, s);
2347 if (textLayoutModule->twoColumnCB->isChecked())
2352 if (textLayoutModule->indentRB->isChecked()) {
2353 // if paragraphs are separated by an indentation
2354 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2355 switch (textLayoutModule->indentCO->currentIndex()) {
2357 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2360 HSpace indent = HSpace(
2361 widgetsToLength(textLayoutModule->indentLE,
2362 textLayoutModule->indentLengthCO)
2364 bp_.setIndentation(indent);
2368 // this should never happen
2369 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2373 // if paragraphs are separated by a skip
2374 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2375 switch (textLayoutModule->skipCO->currentIndex()) {
2377 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2380 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2383 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2388 widgetsToLength(textLayoutModule->skipLE,
2389 textLayoutModule->skipLengthCO)
2395 // this should never happen
2396 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2402 fromqstr(latexModule->optionsLE->text());
2404 bp_.use_default_options =
2405 latexModule->defaultOptionsCB->isChecked();
2407 if (latexModule->childDocGB->isChecked())
2409 fromqstr(latexModule->childDocLE->text());
2411 bp_.master = string();
2414 bp_.clearIncludedChildren();
2415 if (masterChildModule->includeonlyRB->isChecked()) {
2416 list<string>::const_iterator it = includeonlys_.begin();
2417 for (; it != includeonlys_.end() ; ++it) {
2418 bp_.addIncludedChildren(*it);
2421 bp_.maintain_unincluded_children =
2422 masterChildModule->maintainAuxCB->isChecked();
2425 bp_.float_placement = floatModule->get();
2428 // text should have passed validation
2429 bp_.listings_params =
2430 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2433 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2434 outputModule->defaultFormatCO->currentIndex()).toString());
2436 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2437 bp_.useNonTeXFonts = nontexfonts;
2439 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2440 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2442 int mathfmt = outputModule->mathoutCB->currentIndex();
2445 BufferParams::MathOutput const mo =
2446 static_cast<BufferParams::MathOutput>(mathfmt);
2447 bp_.html_math_output = mo;
2448 bp_.html_be_strict = outputModule->strictCB->isChecked();
2449 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2453 if (fontModule->fontsRomanCO->currentIndex() == 0)
2454 bp_.fonts_roman = "default";
2457 fromqstr(fontModule->fontsRomanCO->currentText());
2459 if (fontModule->fontsSansCO->currentIndex() == 0)
2460 bp_.fonts_sans = "default";
2463 fromqstr(fontModule->fontsSansCO->currentText());
2465 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
2466 bp_.fonts_typewriter = "default";
2468 bp_.fonts_typewriter =
2469 fromqstr(fontModule->fontsTypewriterCO->currentText());
2472 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
2475 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
2477 bp_.fonts_typewriter =
2478 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
2481 if (fontModule->fontencCO->currentIndex() == 0)
2482 bp_.fontenc = "global";
2483 else if (fontModule->fontencCO->currentIndex() == 1)
2484 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2485 else if (fontModule->fontencCO->currentIndex() == 2)
2486 bp_.fontenc = "default";
2489 fromqstr(fontModule->cjkFontLE->text());
2491 bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2493 bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2495 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2497 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2500 bp_.fonts_default_family = "default";
2502 bp_.fonts_default_family = GuiDocument::fontfamilies[
2503 fontModule->fontsDefaultCO->currentIndex()];
2505 if (fontModule->fontsizeCO->currentIndex() == 0)
2506 bp_.fontsize = "default";
2509 fromqstr(fontModule->fontsizeCO->currentText());
2512 bp_.papersize = PAPER_SIZE(
2513 pageLayoutModule->papersizeCO->currentIndex());
2515 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2516 pageLayoutModule->paperwidthUnitCO);
2518 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2519 pageLayoutModule->paperheightUnitCO);
2521 if (pageLayoutModule->facingPagesCB->isChecked())
2522 bp_.sides = TwoSides;
2524 bp_.sides = OneSide;
2526 if (pageLayoutModule->landscapeRB->isChecked())
2527 bp_.orientation = ORIENTATION_LANDSCAPE;
2529 bp_.orientation = ORIENTATION_PORTRAIT;
2532 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2534 Ui::MarginsUi const * m = marginsModule;
2536 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2537 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2538 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2539 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2540 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2541 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2542 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2543 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2546 branchesModule->apply(bp_);
2549 PDFOptions & pdf = bp_.pdfoptions();
2550 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2551 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2552 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2553 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2554 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2556 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2557 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2558 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2559 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2561 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2562 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2563 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2564 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2566 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2567 if (pdfSupportModule->fullscreenCB->isChecked())
2568 pdf.pagemode = pdf.pagemode_fullscreen;
2570 pdf.pagemode.clear();
2571 pdf.quoted_options = pdf.quoted_options_check(
2572 fromqstr(pdfSupportModule->optionsLE->text()));
2576 void GuiDocument::paramsToDialog()
2578 // set the default unit
2579 Length::UNIT const defaultUnit = Length::defaultUnit();
2582 preambleModule->update(bp_, id());
2583 localLayout->update(bp_, id());
2586 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2587 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2590 biblioModule->citeDefaultRB->setChecked(
2591 bp_.citeEngine() == ENGINE_BASIC);
2593 biblioModule->citeNatbibRB->setChecked(
2594 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2595 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2597 biblioModule->citeStyleCO->setCurrentIndex(
2598 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2600 biblioModule->citeJurabibRB->setChecked(
2601 bp_.citeEngine() == ENGINE_JURABIB);
2603 biblioModule->bibtopicCB->setChecked(
2608 split(bp_.bibtex_command, command, ' ');
2610 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2612 biblioModule->bibtexCO->setCurrentIndex(bpos);
2613 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2615 // We reset to default if we do not know the specified compiler
2616 // This is for security reasons
2617 biblioModule->bibtexCO->setCurrentIndex(
2618 biblioModule->bibtexCO->findData(toqstr("default")));
2619 biblioModule->bibtexOptionsED->clear();
2621 biblioModule->bibtexOptionsED->setEnabled(
2622 biblioModule->bibtexCO->currentIndex() != 0);
2625 indicesModule->update(bp_);
2627 // language & quotes
2628 int const pos = langModule->languageCO->findData(toqstr(
2629 bp_.language->lang()));
2630 langModule->languageCO->setCurrentIndex(pos);
2632 langModule->quoteStyleCO->setCurrentIndex(
2633 bp_.quotes_language);
2635 bool default_enc = true;
2636 if (bp_.inputenc != "auto") {
2637 default_enc = false;
2638 if (bp_.inputenc == "default") {
2639 langModule->encodingCO->setCurrentIndex(0);
2642 Encodings::const_iterator it = encodings.begin();
2643 Encodings::const_iterator const end = encodings.end();
2644 for (; it != end; ++it) {
2645 if (it->latexName() == bp_.inputenc) {
2646 enc_gui = it->guiName();
2650 int const i = langModule->encodingCO->findText(
2653 langModule->encodingCO->setCurrentIndex(i);
2655 // unknown encoding. Set to default.
2659 langModule->defaultencodingRB->setChecked(default_enc);
2660 langModule->otherencodingRB->setChecked(!default_enc);
2662 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2664 langModule->languagePackageCO->setCurrentIndex(
2665 langModule->languagePackageCO->findData("custom"));
2666 langModule->languagePackageED->setText(toqstr(bp_.lang_package));
2668 langModule->languagePackageCO->setCurrentIndex(p);
2669 langModule->languagePackageED->clear();
2673 if (bp_.isfontcolor) {
2674 colorModule->fontColorPB->setStyleSheet(
2675 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2677 set_fontcolor = bp_.fontcolor;
2678 is_fontcolor = bp_.isfontcolor;
2680 colorModule->noteFontColorPB->setStyleSheet(
2681 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2682 set_notefontcolor = bp_.notefontcolor;
2684 if (bp_.isbackgroundcolor) {
2685 colorModule->backgroundPB->setStyleSheet(
2686 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2688 set_backgroundcolor = bp_.backgroundcolor;
2689 is_backgroundcolor = bp_.isbackgroundcolor;
2691 colorModule->boxBackgroundPB->setStyleSheet(
2692 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2693 set_boxbgcolor = bp_.boxbgcolor;
2696 int const min_toclevel = documentClass().min_toclevel();
2697 int const max_toclevel = documentClass().max_toclevel();
2698 if (documentClass().hasTocLevels()) {
2699 numberingModule->setEnabled(true);
2700 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2701 numberingModule->depthSL->setMaximum(max_toclevel);
2702 numberingModule->depthSL->setValue(bp_.secnumdepth);
2703 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2704 numberingModule->tocSL->setMaximum(max_toclevel);
2705 numberingModule->tocSL->setValue(bp_.tocdepth);
2708 numberingModule->setEnabled(false);
2709 numberingModule->tocTW->clear();
2713 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2714 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2715 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2716 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2717 bulletsModule->init();
2720 int nitem = findToken(tex_graphics, bp_.graphics_driver);
2722 latexModule->psdriverCO->setCurrentIndex(nitem);
2725 mathsModule->amsCB->setChecked(
2726 bp_.use_amsmath == BufferParams::package_on);
2727 mathsModule->amsautoCB->setChecked(
2728 bp_.use_amsmath == BufferParams::package_auto);
2730 mathsModule->esintCB->setChecked(
2731 bp_.use_esint == BufferParams::package_on);
2732 mathsModule->esintautoCB->setChecked(
2733 bp_.use_esint == BufferParams::package_auto);
2735 mathsModule->mhchemCB->setChecked(
2736 bp_.use_mhchem == BufferParams::package_on);
2737 mathsModule->mhchemautoCB->setChecked(
2738 bp_.use_mhchem == BufferParams::package_auto);
2740 mathsModule->mathdotsCB->setChecked(
2741 bp_.use_mathdots == BufferParams::package_on);
2742 mathsModule->mathdotsautoCB->setChecked(
2743 bp_.use_mathdots == BufferParams::package_auto);
2745 switch (bp_.spacing().getSpace()) {
2746 case Spacing::Other: nitem = 3; break;
2747 case Spacing::Double: nitem = 2; break;
2748 case Spacing::Onehalf: nitem = 1; break;
2749 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2753 string const & layoutID = bp_.baseClassID();
2754 setLayoutComboByIDString(layoutID);
2756 updatePagestyle(documentClass().opt_pagestyle(),
2759 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2760 if (bp_.spacing().getSpace() == Spacing::Other) {
2761 doubleToWidget(textLayoutModule->lspacingLE,
2762 bp_.spacing().getValueAsString());
2766 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2767 textLayoutModule->indentRB->setChecked(true);
2768 string indentation = bp_.getIndentation().asLyXCommand();
2770 if (indentation != "default") {
2771 lengthToWidgets(textLayoutModule->indentLE,
2772 textLayoutModule->indentLengthCO,
2773 indentation, defaultUnit);
2776 textLayoutModule->indentCO->setCurrentIndex(indent);
2779 textLayoutModule->skipRB->setChecked(true);
2781 switch (bp_.getDefSkip().kind()) {
2782 case VSpace::SMALLSKIP:
2785 case VSpace::MEDSKIP:
2788 case VSpace::BIGSKIP:
2791 case VSpace::LENGTH:
2794 string const length = bp_.getDefSkip().asLyXCommand();
2795 lengthToWidgets(textLayoutModule->skipLE,
2796 textLayoutModule->skipLengthCO,
2797 length, defaultUnit);
2804 textLayoutModule->skipCO->setCurrentIndex(skip);
2808 textLayoutModule->twoColumnCB->setChecked(
2811 if (!bp_.options.empty()) {
2812 latexModule->optionsLE->setText(
2813 toqstr(bp_.options));
2815 latexModule->optionsLE->setText(QString());
2819 latexModule->defaultOptionsCB->setChecked(
2820 bp_.use_default_options);
2821 updateSelectedModules();
2822 selectionManager->updateProvidedModules(
2823 bp_.baseClass()->providedModules());
2824 selectionManager->updateExcludedModules(
2825 bp_.baseClass()->excludedModules());
2827 if (!documentClass().options().empty()) {
2828 latexModule->defaultOptionsLE->setText(
2829 toqstr(documentClass().options()));
2831 latexModule->defaultOptionsLE->setText(
2832 toqstr(_("[No options predefined]")));
2835 latexModule->defaultOptionsLE->setEnabled(
2836 bp_.use_default_options
2837 && !documentClass().options().empty());
2839 latexModule->defaultOptionsCB->setEnabled(
2840 !documentClass().options().empty());
2842 if (!bp_.master.empty()) {
2843 latexModule->childDocGB->setChecked(true);
2844 latexModule->childDocLE->setText(
2845 toqstr(bp_.master));
2847 latexModule->childDocLE->setText(QString());
2848 latexModule->childDocGB->setChecked(false);
2852 if (!bufferview() || !buffer().hasChildren()) {
2853 masterChildModule->childrenTW->clear();
2854 includeonlys_.clear();
2855 docPS->showPanel(qt_("Child Documents"), false);
2856 if (docPS->isCurrentPanel(qt_("Child Documents")))
2857 docPS->setCurrentPanel(qt_("Document Class"));
2859 docPS->showPanel(qt_("Child Documents"), true);
2860 masterChildModule->setEnabled(true);
2861 includeonlys_ = bp_.getIncludedChildren();
2862 updateIncludeonlys();
2864 masterChildModule->maintainAuxCB->setChecked(
2865 bp_.maintain_unincluded_children);
2868 floatModule->set(bp_.float_placement);
2871 // break listings_params to multiple lines
2873 InsetListingsParams(bp_.listings_params).separatedParams();
2874 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2877 // update combobox with formats
2878 updateDefaultFormat();
2879 int index = outputModule->defaultFormatCO->findData(toqstr(
2880 bp_.default_output_format));
2881 // set to default if format is not found
2884 outputModule->defaultFormatCO->setCurrentIndex(index);
2885 bool const os_fonts_available =
2886 bp_.baseClass()->outputType() == lyx::LATEX
2887 && LaTeXFeatures::isAvailable("fontspec");
2888 fontModule->osFontsCB->setEnabled(os_fonts_available);
2889 fontModule->osFontsCB->setChecked(
2890 os_fonts_available && bp_.useNonTeXFonts);
2892 outputModule->outputsyncCB->setChecked(bp_.output_sync);
2893 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2895 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2896 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2897 outputModule->strictCB->setChecked(bp_.html_be_strict);
2900 updateFontsize(documentClass().opt_fontsize(),
2903 if (bp_.useNonTeXFonts && os_fonts_available) {
2904 fontModule->fontencLA->setEnabled(false);
2905 fontModule->fontencCO->setEnabled(false);
2906 fontModule->fontencLE->setEnabled(false);
2907 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2908 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fonts_roman)) {
2909 fontModule->fontsRomanCO->setCurrentIndex(i);
2914 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2915 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fonts_sans)) {
2916 fontModule->fontsSansCO->setCurrentIndex(i);
2920 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2921 if (fontModule->fontsTypewriterCO->itemText(i) ==
2922 toqstr(bp_.fonts_typewriter)) {
2923 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2928 fontModule->fontencLA->setEnabled(true);
2929 fontModule->fontencCO->setEnabled(true);
2930 fontModule->fontencLE->setEnabled(true);
2931 int n = findToken(tex_fonts_roman, bp_.fonts_roman);
2933 fontModule->fontsRomanCO->setCurrentIndex(n);
2937 n = findToken(tex_fonts_sans, bp_.fonts_sans);
2939 fontModule->fontsSansCO->setCurrentIndex(n);
2943 n = findToken(tex_fonts_monospaced, bp_.fonts_typewriter);
2945 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2950 if (!bp_.fonts_cjk.empty())
2951 fontModule->cjkFontLE->setText(
2952 toqstr(bp_.fonts_cjk));
2954 fontModule->cjkFontLE->setText(QString());
2956 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
2957 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
2958 fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
2959 fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
2961 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
2963 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2965 if (bp_.fontenc == "global") {
2966 fontModule->fontencCO->setCurrentIndex(0);
2967 fontModule->fontencLE->setEnabled(false);
2968 } else if (bp_.fontenc == "default") {
2969 fontModule->fontencCO->setCurrentIndex(2);
2970 fontModule->fontencLE->setEnabled(false);
2972 fontModule->fontencCO->setCurrentIndex(1);
2973 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2977 bool const extern_geometry =
2978 documentClass().provides("geometry");
2979 int const psize = bp_.papersize;
2980 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2981 setCustomPapersize(!extern_geometry && psize == 1);
2982 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2984 bool const landscape =
2985 bp_.orientation == ORIENTATION_LANDSCAPE;
2986 pageLayoutModule->landscapeRB->setChecked(landscape);
2987 pageLayoutModule->portraitRB->setChecked(!landscape);
2988 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2989 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2991 pageLayoutModule->facingPagesCB->setChecked(
2992 bp_.sides == TwoSides);
2994 lengthToWidgets(pageLayoutModule->paperwidthLE,
2995 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2996 lengthToWidgets(pageLayoutModule->paperheightLE,
2997 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
3000 Ui::MarginsUi * m = marginsModule;
3004 lengthToWidgets(m->topLE, m->topUnit,
3005 bp_.topmargin, defaultUnit);
3007 lengthToWidgets(m->bottomLE, m->bottomUnit,
3008 bp_.bottommargin, defaultUnit);
3010 lengthToWidgets(m->innerLE, m->innerUnit,
3011 bp_.leftmargin, defaultUnit);
3013 lengthToWidgets(m->outerLE, m->outerUnit,
3014 bp_.rightmargin, defaultUnit);
3016 lengthToWidgets(m->headheightLE, m->headheightUnit,
3017 bp_.headheight, defaultUnit);
3019 lengthToWidgets(m->headsepLE, m->headsepUnit,
3020 bp_.headsep, defaultUnit);
3022 lengthToWidgets(m->footskipLE, m->footskipUnit,
3023 bp_.footskip, defaultUnit);
3025 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3026 bp_.columnsep, defaultUnit);
3029 updateUnknownBranches();
3030 branchesModule->update(bp_);
3033 PDFOptions const & pdf = bp_.pdfoptions();
3034 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3035 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3036 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3037 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3038 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3040 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3041 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3042 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3044 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3046 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3047 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3048 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3049 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3051 nn = findToken(backref_opts, pdf.backref);
3053 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3055 pdfSupportModule->fullscreenCB->setChecked
3056 (pdf.pagemode == pdf.pagemode_fullscreen);
3058 pdfSupportModule->optionsLE->setText(
3059 toqstr(pdf.quoted_options));
3061 // Make sure that the bc is in the INITIAL state
3062 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3065 // clear changed branches cache
3066 changedBranches_.clear();
3070 void GuiDocument::saveDocDefault()
3072 // we have to apply the params first
3078 void GuiDocument::updateAvailableModules()
3080 modules_av_model_.clear();
3081 list<modInfoStruct> const & modInfoList = getModuleInfo();
3082 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3083 list<modInfoStruct>::const_iterator men = modInfoList.end();
3084 for (int i = 0; mit != men; ++mit, ++i)
3085 modules_av_model_.insertRow(i, mit->name, mit->id,
3090 void GuiDocument::updateSelectedModules()
3092 modules_sel_model_.clear();
3093 list<modInfoStruct> const selModList = getSelectedModules();
3094 list<modInfoStruct>::const_iterator mit = selModList.begin();
3095 list<modInfoStruct>::const_iterator men = selModList.end();
3096 for (int i = 0; mit != men; ++mit, ++i)
3097 modules_sel_model_.insertRow(i, mit->name, mit->id,
3102 void GuiDocument::updateIncludeonlys()
3104 masterChildModule->childrenTW->clear();
3105 QString const no = qt_("No");
3106 QString const yes = qt_("Yes");
3108 if (includeonlys_.empty()) {
3109 masterChildModule->includeallRB->setChecked(true);
3110 masterChildModule->childrenTW->setEnabled(false);
3111 masterChildModule->maintainAuxCB->setEnabled(false);
3113 masterChildModule->includeonlyRB->setChecked(true);
3114 masterChildModule->childrenTW->setEnabled(true);
3115 masterChildModule->maintainAuxCB->setEnabled(true);
3117 QTreeWidgetItem * item = 0;
3118 ListOfBuffers children = buffer().getChildren();
3119 ListOfBuffers::const_iterator it = children.begin();
3120 ListOfBuffers::const_iterator end = children.end();
3121 bool has_unincluded = false;
3122 bool all_unincluded = true;
3123 for (; it != end; ++it) {
3124 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3127 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3128 from_utf8(buffer().filePath())));
3129 item->setText(0, toqstr(name));
3130 item->setText(1, isChildIncluded(name) ? yes : no);
3131 if (!isChildIncluded(name))
3132 has_unincluded = true;
3134 all_unincluded = false;
3136 // Both if all childs are included and if none is included
3137 // is equal to "include all" (i.e., ommit \includeonly).
3138 // Thus, reset the GUI.
3139 if (!has_unincluded || all_unincluded) {
3140 masterChildModule->includeallRB->setChecked(true);
3141 masterChildModule->childrenTW->setEnabled(false);
3142 includeonlys_.clear();
3144 // If all are included, we need to update again.
3145 if (!has_unincluded)
3146 updateIncludeonlys();
3150 void GuiDocument::updateContents()
3152 // Nothing to do here as the document settings is not cursor dependant.
3157 void GuiDocument::useClassDefaults()
3159 if (applyPB->isEnabled()) {
3160 int const ret = Alert::prompt(_("Unapplied changes"),
3161 _("Some changes in the dialog were not yet applied.\n"
3162 "If you do not apply now, they will be lost after this action."),
3163 1, 1, _("&Apply"), _("&Dismiss"));
3168 int idx = latexModule->classCO->currentIndex();
3169 string const classname = classes_model_.getIDString(idx);
3170 if (!bp_.setBaseClass(classname)) {
3171 Alert::error(_("Error"), _("Unable to set document class."));
3174 bp_.useClassDefaults();
3179 void GuiDocument::setLayoutComboByIDString(string const & idString)
3181 int idx = classes_model_.findIDString(idString);
3183 Alert::warning(_("Can't set layout!"),
3184 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3186 latexModule->classCO->setCurrentIndex(idx);
3190 bool GuiDocument::isValid()
3193 validateListingsParameters().isEmpty() &&
3194 localLayout->isValid() &&
3196 // if we're asking for skips between paragraphs
3197 !textLayoutModule->skipRB->isChecked() ||
3198 // then either we haven't chosen custom
3199 textLayoutModule->skipCO->currentIndex() != 3 ||
3200 // or else a length has been given
3201 !textLayoutModule->skipLE->text().isEmpty()
3204 // if we're asking for indentation
3205 !textLayoutModule->indentRB->isChecked() ||
3206 // then either we haven't chosen custom
3207 textLayoutModule->indentCO->currentIndex() != 1 ||
3208 // or else a length has been given
3209 !textLayoutModule->indentLE->text().isEmpty()
3214 char const * const GuiDocument::fontfamilies[5] = {
3215 "default", "rmdefault", "sfdefault", "ttdefault", ""
3219 char const * GuiDocument::fontfamilies_gui[5] = {
3220 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3224 bool GuiDocument::initialiseParams(string const &)
3226 BufferView const * view = bufferview();
3228 bp_ = BufferParams();
3232 bp_ = view->buffer().params();
3234 updateAvailableModules();
3235 //FIXME It'd be nice to make sure here that the selected
3236 //modules are consistent: That required modules are actually
3237 //selected, and that we don't have conflicts. If so, we could
3238 //at least pop up a warning.
3244 void GuiDocument::clearParams()
3246 bp_ = BufferParams();
3250 BufferId GuiDocument::id() const
3252 BufferView const * const view = bufferview();
3253 return view? &view->buffer() : 0;
3257 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3259 return moduleNames_;
3263 list<GuiDocument::modInfoStruct> const
3264 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3266 LayoutModuleList::const_iterator it = mods.begin();
3267 LayoutModuleList::const_iterator end = mods.end();
3268 list<modInfoStruct> mInfo;
3269 for (; it != end; ++it) {
3272 LyXModule const * const mod = theModuleList[*it];
3275 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3277 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3284 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3286 return makeModuleInfo(params().getModules());
3290 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3292 return makeModuleInfo(params().baseClass()->providedModules());
3296 DocumentClass const & GuiDocument::documentClass() const
3298 return bp_.documentClass();
3302 static void dispatch_bufferparams(Dialog const & dialog,
3303 BufferParams const & bp, FuncCode lfun)
3306 ss << "\\begin_header\n";
3308 ss << "\\end_header\n";
3309 dialog.dispatch(FuncRequest(lfun, ss.str()));
3313 void GuiDocument::dispatchParams()
3315 // This must come first so that a language change is correctly noticed
3318 // Apply the BufferParams. Note that this will set the base class
3319 // and then update the buffer's layout.
3320 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3322 if (!params().master.empty()) {
3323 FileName const master_file = support::makeAbsPath(params().master,
3324 support::onlyPath(buffer().absFileName()));
3325 if (isLyXFileName(master_file.absFileName())) {
3326 Buffer * master = checkAndLoadLyXFile(master_file);
3328 if (master->isChild(const_cast<Buffer *>(&buffer())))
3329 const_cast<Buffer &>(buffer()).setParent(master);
3331 Alert::warning(_("Assigned master does not include this file"),
3332 bformat(_("You must include this file in the document\n"
3333 "'%1$s' in order to use the master document\n"
3334 "feature."), from_utf8(params().master)));
3336 Alert::warning(_("Could not load master"),
3337 bformat(_("The master document '%1$s'\n"
3338 "could not be loaded."),
3339 from_utf8(params().master)));
3343 // Generate the colours requested by each new branch.
3344 BranchList & branchlist = params().branchlist();
3345 if (!branchlist.empty()) {
3346 BranchList::const_iterator it = branchlist.begin();
3347 BranchList::const_iterator const end = branchlist.end();
3348 for (; it != end; ++it) {
3349 docstring const & current_branch = it->branch();
3350 Branch const * branch = branchlist.find(current_branch);
3351 string const x11hexname = X11hexname(branch->color());
3352 // display the new color
3353 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3354 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3357 // Open insets of selected branches, close deselected ones
3358 dispatch(FuncRequest(LFUN_INSET_FORALL,
3359 "Branch inset-toggle assign"));
3361 // rename branches in the document
3362 executeBranchRenaming();
3363 // and clear changed branches cache
3364 changedBranches_.clear();
3366 // Generate the colours requested by indices.
3367 IndicesList & indiceslist = params().indiceslist();
3368 if (!indiceslist.empty()) {
3369 IndicesList::const_iterator it = indiceslist.begin();
3370 IndicesList::const_iterator const end = indiceslist.end();
3371 for (; it != end; ++it) {
3372 docstring const & current_index = it->shortcut();
3373 Index const * index = indiceslist.findShortcut(current_index);
3374 string const x11hexname = X11hexname(index->color());
3375 // display the new color
3376 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3377 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3381 // If we used an LFUN, we would not need these two lines:
3382 BufferView * bv = const_cast<BufferView *>(bufferview());
3383 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3387 void GuiDocument::setLanguage() const
3389 Language const * const newL = bp_.language;
3390 if (buffer().params().language == newL)
3393 string const & lang_name = newL->lang();
3394 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3398 void GuiDocument::saveAsDefault() const
3400 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3404 bool GuiDocument::isFontAvailable(string const & font) const
3406 if (font == "default" || font == "cmr"
3407 || font == "cmss" || font == "cmtt")
3408 // these are standard
3410 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3411 return LaTeXFeatures::isAvailable("lmodern");
3412 if (font == "times" || font == "palatino"
3413 || font == "helvet" || font == "courier")
3414 return LaTeXFeatures::isAvailable("psnfss");
3415 if (font == "cmbr" || font == "cmtl")
3416 return LaTeXFeatures::isAvailable("cmbright");
3417 if (font == "utopia")
3418 return LaTeXFeatures::isAvailable("utopia")
3419 || LaTeXFeatures::isAvailable("fourier");
3420 if (font == "beraserif" || font == "berasans"
3421 || font == "beramono")
3422 return LaTeXFeatures::isAvailable("bera");
3423 return LaTeXFeatures::isAvailable(font);
3427 bool GuiDocument::providesOSF(string const & font) const
3429 if (fontModule->osFontsCB->isChecked())
3430 // FIXME: we should check if the fonts really
3431 // have OSF support. But how?
3434 return isFontAvailable("eco");
3435 if (font == "palatino")
3436 return isFontAvailable("mathpazo");
3441 bool GuiDocument::providesSC(string const & font) const
3443 if (fontModule->osFontsCB->isChecked())
3445 if (font == "palatino")
3446 return isFontAvailable("mathpazo");
3447 if (font == "utopia")
3448 return isFontAvailable("fourier");
3453 bool GuiDocument::providesScale(string const & font) const
3455 if (fontModule->osFontsCB->isChecked())
3457 return font == "helvet" || font == "luximono"
3458 || font == "berasans" || font == "beramono";
3462 void GuiDocument::loadModuleInfo()
3464 moduleNames_.clear();
3465 LyXModuleList::const_iterator it = theModuleList.begin();
3466 LyXModuleList::const_iterator end = theModuleList.end();
3467 for (; it != end; ++it) {
3471 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3472 // this is supposed to give us the first sentence of the description
3475 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3476 int const pos = desc.indexOf(".");
3478 desc.truncate(pos + 1);
3479 m.description = desc;
3480 moduleNames_.push_back(m);
3485 void GuiDocument::updateUnknownBranches()
3489 list<docstring> used_branches;
3490 buffer().getUsedBranches(used_branches);
3491 list<docstring>::const_iterator it = used_branches.begin();
3492 QStringList unknown_branches;
3493 for (; it != used_branches.end() ; ++it) {
3494 if (!buffer().params().branchlist().find(*it))
3495 unknown_branches.append(toqstr(*it));
3497 branchesModule->setUnknownBranches(unknown_branches);
3501 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3503 map<docstring, docstring>::iterator it = changedBranches_.begin();
3504 for (; it != changedBranches_.end() ; ++it) {
3505 if (it->second == oldname) {
3506 // branch has already been renamed
3507 it->second = newname;
3512 changedBranches_[oldname] = newname;
3516 void GuiDocument::executeBranchRenaming() const
3518 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3519 for (; it != changedBranches_.end() ; ++it) {
3520 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3521 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3526 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3529 } // namespace frontend
3532 #include "moc_GuiDocument.cpp"