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(qt_("&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 empty StyleSheet
1522 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1523 // change button text
1524 colorModule->backgroundPB->setText(qt_("&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(qt_("&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 empty StyleSheet
1552 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1553 // change button text
1554 colorModule->fontColorPB->setText(qt_("&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 pref
1580 theApp()->getRgbColor(Color_notebg, set_notefontcolor);
1581 colorModule->noteFontColorPB->setStyleSheet(
1582 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1587 void GuiDocument::changeBoxBackgroundColor()
1589 QColor const & newColor = QColorDialog::getColor(
1590 rgb2qcolor(set_boxbgcolor), asQWidget());
1591 if (!newColor.isValid())
1593 // set the button color
1594 colorModule->boxBackgroundPB->setStyleSheet(
1595 colorButtonStyleSheet(newColor));
1597 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1602 void GuiDocument::deleteBoxBackgroundColor()
1604 // set the button color back to pref
1605 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1606 colorModule->boxBackgroundPB->setStyleSheet(
1607 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1612 void GuiDocument::osFontsChanged(bool nontexfonts)
1614 bool const tex_fonts = !nontexfonts;
1616 updateDefaultFormat();
1617 langModule->encodingCO->setEnabled(tex_fonts &&
1618 !langModule->defaultencodingRB->isChecked());
1619 langModule->defaultencodingRB->setEnabled(tex_fonts);
1620 langModule->otherencodingRB->setEnabled(tex_fonts);
1622 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1623 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1624 fontModule->cjkFontLE->setEnabled(tex_fonts);
1625 fontModule->cjkFontLA->setEnabled(tex_fonts);
1628 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1629 bool scaleable = providesScale(font);
1630 fontModule->scaleSansSB->setEnabled(scaleable);
1631 fontModule->scaleSansLA->setEnabled(scaleable);
1633 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1634 scaleable = providesScale(font);
1635 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1636 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1638 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1639 fontModule->fontScCB->setEnabled(providesSC(font));
1640 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1642 fontModule->fontencLA->setEnabled(tex_fonts);
1643 fontModule->fontencCO->setEnabled(tex_fonts);
1645 fontModule->fontencLE->setEnabled(false);
1647 fontencChanged(fontModule->fontencCO->currentIndex());
1651 void GuiDocument::updateFontsize(string const & items, string const & sel)
1653 fontModule->fontsizeCO->clear();
1654 fontModule->fontsizeCO->addItem(qt_("Default"));
1656 for (int n = 0; !token(items,'|',n).empty(); ++n)
1657 fontModule->fontsizeCO->
1658 addItem(toqstr(token(items,'|',n)));
1660 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1661 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1662 fontModule->fontsizeCO->setCurrentIndex(n);
1669 void GuiDocument::updateFontlist()
1671 fontModule->fontsRomanCO->clear();
1672 fontModule->fontsSansCO->clear();
1673 fontModule->fontsTypewriterCO->clear();
1675 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1676 if (fontModule->osFontsCB->isChecked()) {
1677 fontModule->fontsRomanCO->addItem(qt_("Default"));
1678 fontModule->fontsSansCO->addItem(qt_("Default"));
1679 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1681 QFontDatabase fontdb;
1682 QStringList families(fontdb.families());
1683 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1684 fontModule->fontsRomanCO->addItem(*it);
1685 fontModule->fontsSansCO->addItem(*it);
1686 fontModule->fontsTypewriterCO->addItem(*it);
1691 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1692 QString font = qt_(tex_fonts_roman_gui[n]);
1693 if (!isFontAvailable(tex_fonts_roman[n]))
1694 font += qt_(" (not installed)");
1695 fontModule->fontsRomanCO->addItem(font);
1697 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1698 QString font = qt_(tex_fonts_sans_gui[n]);
1699 if (!isFontAvailable(tex_fonts_sans[n]))
1700 font += qt_(" (not installed)");
1701 fontModule->fontsSansCO->addItem(font);
1703 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1704 QString font = qt_(tex_fonts_monospaced_gui[n]);
1705 if (!isFontAvailable(tex_fonts_monospaced[n]))
1706 font += qt_(" (not installed)");
1707 fontModule->fontsTypewriterCO->addItem(font);
1712 void GuiDocument::fontencChanged(int item)
1714 fontModule->fontencLE->setEnabled(item == 1);
1718 void GuiDocument::romanChanged(int item)
1720 if (fontModule->osFontsCB->isChecked())
1722 string const font = tex_fonts_roman[item];
1723 fontModule->fontScCB->setEnabled(providesSC(font));
1724 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1728 void GuiDocument::sansChanged(int item)
1730 if (fontModule->osFontsCB->isChecked())
1732 string const font = tex_fonts_sans[item];
1733 bool scaleable = providesScale(font);
1734 fontModule->scaleSansSB->setEnabled(scaleable);
1735 fontModule->scaleSansLA->setEnabled(scaleable);
1739 void GuiDocument::ttChanged(int item)
1741 if (fontModule->osFontsCB->isChecked())
1743 string const font = tex_fonts_monospaced[item];
1744 bool scaleable = providesScale(font);
1745 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1746 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1750 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1753 pageLayoutModule->pagestyleCO->clear();
1754 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1756 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1757 string style = token(items, '|', n);
1758 QString style_gui = qt_(style);
1759 pagestyles.push_back(pair<string, QString>(style, style_gui));
1760 pageLayoutModule->pagestyleCO->addItem(style_gui);
1763 if (sel == "default") {
1764 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1770 for (size_t i = 0; i < pagestyles.size(); ++i)
1771 if (pagestyles[i].first == sel)
1772 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1775 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1779 void GuiDocument::browseLayout()
1781 QString const label1 = qt_("Layouts|#o#O");
1782 QString const dir1 = toqstr(lyxrc.document_path);
1783 QStringList const filter(qt_("LyX Layout (*.layout)"));
1784 QString file = browseRelFile(QString(), bufferFilePath(),
1785 qt_("Local layout file"), filter, false,
1788 if (!file.endsWith(".layout"))
1791 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1792 fromqstr(bufferFilePath()));
1794 int const ret = Alert::prompt(_("Local layout file"),
1795 _("The layout file you have selected is a local layout\n"
1796 "file, not one in the system or user directory. Your\n"
1797 "document may not work with this layout if you do not\n"
1798 "keep the layout file in the document directory."),
1799 1, 1, _("&Set Layout"), _("&Cancel"));
1803 // load the layout file
1804 LayoutFileList & bcl = LayoutFileList::get();
1805 string classname = layoutFile.onlyFileName();
1806 // this will update an existing layout if that layout has been loaded before.
1807 LayoutFileIndex name = bcl.addLocalLayout(
1808 classname.substr(0, classname.size() - 7),
1809 layoutFile.onlyPath().absFileName());
1812 Alert::error(_("Error"),
1813 _("Unable to read local layout file."));
1817 // do not trigger classChanged if there is no change.
1818 if (latexModule->classCO->currentText() == toqstr(name))
1822 int idx = latexModule->classCO->findText(toqstr(name));
1824 classes_model_.insertRow(0, toqstr(name), name);
1825 latexModule->classCO->setCurrentIndex(0);
1827 latexModule->classCO->setCurrentIndex(idx);
1833 void GuiDocument::browseMaster()
1835 QString const title = qt_("Select master document");
1836 QString const dir1 = toqstr(lyxrc.document_path);
1837 QString const old = latexModule->childDocLE->text();
1838 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1839 QStringList const filter(qt_("LyX Files (*.lyx)"));
1840 QString file = browseRelFile(old, docpath, title, filter, false,
1841 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1843 if (!file.isEmpty())
1844 latexModule->childDocLE->setText(file);
1848 void GuiDocument::classChanged()
1850 int idx = latexModule->classCO->currentIndex();
1853 string const classname = classes_model_.getIDString(idx);
1855 // check whether the selected modules have changed.
1856 bool modules_changed = false;
1857 unsigned int const srows = selectedModel()->rowCount();
1858 if (srows != bp_.getModules().size())
1859 modules_changed = true;
1861 list<string>::const_iterator mit = bp_.getModules().begin();
1862 list<string>::const_iterator men = bp_.getModules().end();
1863 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1864 if (selectedModel()->getIDString(i) != *mit) {
1865 modules_changed = true;
1870 if (modules_changed || lyxrc.auto_reset_options) {
1871 if (applyPB->isEnabled()) {
1872 int const ret = Alert::prompt(_("Unapplied changes"),
1873 _("Some changes in the dialog were not yet applied.\n"
1874 "If you do not apply now, they will be lost after this action."),
1875 1, 1, _("&Apply"), _("&Dismiss"));
1881 // We load the TextClass as soon as it is selected. This is
1882 // necessary so that other options in the dialog can be updated
1883 // according to the new class. Note, however, that, if you use
1884 // the scroll wheel when sitting on the combo box, we'll load a
1885 // lot of TextClass objects very quickly....
1886 if (!bp_.setBaseClass(classname)) {
1887 Alert::error(_("Error"), _("Unable to set document class."));
1890 if (lyxrc.auto_reset_options)
1891 bp_.useClassDefaults();
1893 // With the introduction of modules came a distinction between the base
1894 // class and the document class. The former corresponds to the main layout
1895 // file; the latter is that plus the modules (or the document-specific layout,
1896 // or whatever else there could be). Our parameters come from the document
1897 // class. So when we set the base class, we also need to recreate the document
1898 // class. Otherwise, we still have the old one.
1899 bp_.makeDocumentClass();
1904 void GuiDocument::languagePackageChanged(int i)
1906 langModule->languagePackageED->setEnabled(
1907 langModule->languagePackageCO->itemData(i).toString() == "custom");
1911 void GuiDocument::bibtexChanged(int n)
1913 biblioModule->bibtexOptionsED->setEnabled(
1914 biblioModule->bibtexCO->itemData(n).toString() != "default");
1921 // both of these should take a vector<docstring>
1923 // This is an insanely complicated attempt to make this sort of thing
1924 // work with RTL languages.
1925 docstring formatStrVec(vector<string> const & v, docstring const & s)
1927 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1931 return translateIfPossible(from_utf8(v[0]));
1932 if (v.size() == 2) {
1933 docstring retval = _("%1$s and %2$s");
1934 retval = subst(retval, _("and"), s);
1935 return bformat(retval, translateIfPossible(from_utf8(v[0])),
1936 translateIfPossible(from_utf8(v[1])));
1938 // The idea here is to format all but the last two items...
1939 int const vSize = v.size();
1940 docstring t2 = _("%1$s, %2$s");
1941 docstring retval = translateIfPossible(from_utf8(v[0]));
1942 for (int i = 1; i < vSize - 2; ++i)
1943 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
1944 //...and then to plug them, and the last two, into this schema
1945 docstring t = _("%1$s, %2$s, and %3$s");
1946 t = subst(t, _("and"), s);
1947 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
1948 translateIfPossible(from_utf8(v[vSize - 1])));
1951 vector<string> idsToNames(vector<string> const & idList)
1953 vector<string> retval;
1954 vector<string>::const_iterator it = idList.begin();
1955 vector<string>::const_iterator end = idList.end();
1956 for (; it != end; ++it) {
1957 LyXModule const * const mod = theModuleList[*it];
1959 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
1960 translateIfPossible(from_utf8(*it)))));
1962 retval.push_back(mod->getName());
1966 } // end anonymous namespace
1969 void GuiDocument::modulesToParams(BufferParams & bp)
1971 // update list of loaded modules
1972 bp.clearLayoutModules();
1973 int const srows = modules_sel_model_.rowCount();
1974 for (int i = 0; i < srows; ++i)
1975 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1977 // update the list of removed modules
1978 bp.clearRemovedModules();
1979 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1980 list<string>::const_iterator rit = reqmods.begin();
1981 list<string>::const_iterator ren = reqmods.end();
1983 // check each of the default modules
1984 for (; rit != ren; rit++) {
1985 list<string>::const_iterator mit = bp.getModules().begin();
1986 list<string>::const_iterator men = bp.getModules().end();
1988 for (; mit != men; mit++) {
1995 // the module isn't present so must have been removed by the user
1996 bp.addRemovedModule(*rit);
2001 void GuiDocument::modulesChanged()
2003 modulesToParams(bp_);
2004 bp_.makeDocumentClass();
2009 void GuiDocument::updateModuleInfo()
2011 selectionManager->update();
2013 //Module description
2014 bool const focus_on_selected = selectionManager->selectedFocused();
2015 QAbstractItemView * lv;
2016 if (focus_on_selected)
2017 lv = modulesModule->selectedLV;
2019 lv= modulesModule->availableLV;
2020 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2021 modulesModule->infoML->document()->clear();
2024 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2025 GuiIdListModel const & id_model =
2026 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2027 string const modName = id_model.getIDString(idx.row());
2028 docstring desc = getModuleDescription(modName);
2030 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2031 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2034 desc += _("Module provided by document class.");
2037 vector<string> pkglist = getPackageList(modName);
2038 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2039 if (!pkgdesc.empty()) {
2042 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2045 pkglist = getRequiredList(modName);
2046 if (!pkglist.empty()) {
2047 vector<string> const reqdescs = idsToNames(pkglist);
2048 pkgdesc = formatStrVec(reqdescs, _("or"));
2051 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2054 pkglist = getExcludedList(modName);
2055 if (!pkglist.empty()) {
2056 vector<string> const reqdescs = idsToNames(pkglist);
2057 pkgdesc = formatStrVec(reqdescs, _( "and"));
2060 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2063 if (!isModuleAvailable(modName)) {
2066 desc += _("WARNING: Some required packages are unavailable!");
2069 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2073 void GuiDocument::updateNumbering()
2075 DocumentClass const & tclass = documentClass();
2077 numberingModule->tocTW->setUpdatesEnabled(false);
2078 numberingModule->tocTW->clear();
2080 int const depth = numberingModule->depthSL->value();
2081 int const toc = numberingModule->tocSL->value();
2082 QString const no = qt_("No");
2083 QString const yes = qt_("Yes");
2084 QTreeWidgetItem * item = 0;
2086 DocumentClass::const_iterator lit = tclass.begin();
2087 DocumentClass::const_iterator len = tclass.end();
2088 for (; lit != len; ++lit) {
2089 int const toclevel = lit->toclevel;
2090 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2091 item = new QTreeWidgetItem(numberingModule->tocTW);
2092 item->setText(0, toqstr(translateIfPossible(lit->name())));
2093 item->setText(1, (toclevel <= depth) ? yes : no);
2094 item->setText(2, (toclevel <= toc) ? yes : no);
2098 numberingModule->tocTW->setUpdatesEnabled(true);
2099 numberingModule->tocTW->update();
2103 void GuiDocument::updateDefaultFormat()
2107 // make a copy in order to consider unapplied changes
2108 Buffer * tmpbuf = buffer().clone();
2109 tmpbuf->params().useNonTeXFonts =
2110 fontModule->osFontsCB->isChecked();
2111 int idx = latexModule->classCO->currentIndex();
2113 string const classname = classes_model_.getIDString(idx);
2114 tmpbuf->params().setBaseClass(classname);
2115 tmpbuf->params().makeDocumentClass();
2117 outputModule->defaultFormatCO->blockSignals(true);
2118 outputModule->defaultFormatCO->clear();
2119 outputModule->defaultFormatCO->addItem(qt_("Default"),
2120 QVariant(QString("default")));
2121 typedef vector<Format const *> Formats;
2122 Formats formats = tmpbuf->exportableFormats(true);
2123 Formats::const_iterator cit = formats.begin();
2124 Formats::const_iterator end = formats.end();
2125 for (; cit != end; ++cit)
2126 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2127 QVariant(toqstr((*cit)->name())));
2128 outputModule->defaultFormatCO->blockSignals(false);
2134 bool GuiDocument::isChildIncluded(string const & child)
2136 if (includeonlys_.empty())
2138 return (std::find(includeonlys_.begin(),
2139 includeonlys_.end(), child) != includeonlys_.end());
2143 void GuiDocument::applyView()
2146 preambleModule->apply(bp_);
2147 localLayout->apply(bp_);
2150 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2151 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2154 bp_.setCiteEngine(ENGINE_BASIC);
2156 if (biblioModule->citeNatbibRB->isChecked()) {
2157 bool const use_numerical_citations =
2158 biblioModule->citeStyleCO->currentIndex();
2159 if (use_numerical_citations)
2160 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2162 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2164 } else if (biblioModule->citeJurabibRB->isChecked())
2165 bp_.setCiteEngine(ENGINE_JURABIB);
2168 biblioModule->bibtopicCB->isChecked();
2170 string const bibtex_command =
2171 fromqstr(biblioModule->bibtexCO->itemData(
2172 biblioModule->bibtexCO->currentIndex()).toString());
2173 string const bibtex_options =
2174 fromqstr(biblioModule->bibtexOptionsED->text());
2175 if (bibtex_command == "default" || bibtex_options.empty())
2176 bp_.bibtex_command = bibtex_command;
2178 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2181 indicesModule->apply(bp_);
2183 // language & quotes
2184 if (langModule->defaultencodingRB->isChecked()) {
2185 bp_.inputenc = "auto";
2187 int i = langModule->encodingCO->currentIndex();
2189 bp_.inputenc = "default";
2191 QString const enc_gui =
2192 langModule->encodingCO->currentText();
2193 Encodings::const_iterator it = encodings.begin();
2194 Encodings::const_iterator const end = encodings.end();
2196 for (; it != end; ++it) {
2197 if (qt_(it->guiName()) == enc_gui) {
2198 bp_.inputenc = it->latexName();
2204 // should not happen
2205 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2206 bp_.inputenc = "default";
2211 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2212 switch (langModule->quoteStyleCO->currentIndex()) {
2214 lga = InsetQuotes::EnglishQuotes;
2217 lga = InsetQuotes::SwedishQuotes;
2220 lga = InsetQuotes::GermanQuotes;
2223 lga = InsetQuotes::PolishQuotes;
2226 lga = InsetQuotes::FrenchQuotes;
2229 lga = InsetQuotes::DanishQuotes;
2232 bp_.quotes_language = lga;
2234 QString const lang = langModule->languageCO->itemData(
2235 langModule->languageCO->currentIndex()).toString();
2236 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2238 QString const pack = langModule->languagePackageCO->itemData(
2239 langModule->languagePackageCO->currentIndex()).toString();
2240 if (pack == "custom")
2242 fromqstr(langModule->languagePackageED->text());
2244 bp_.lang_package = fromqstr(pack);
2247 bp_.backgroundcolor = set_backgroundcolor;
2248 bp_.isbackgroundcolor = is_backgroundcolor;
2249 bp_.fontcolor = set_fontcolor;
2250 bp_.isfontcolor = is_fontcolor;
2251 bp_.notefontcolor = set_notefontcolor;
2252 bp_.boxbgcolor = set_boxbgcolor;
2255 if (bp_.documentClass().hasTocLevels()) {
2256 bp_.tocdepth = numberingModule->tocSL->value();
2257 bp_.secnumdepth = numberingModule->depthSL->value();
2261 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2262 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2263 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2264 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2267 bp_.graphics_driver =
2268 tex_graphics[latexModule->psdriverCO->currentIndex()];
2271 int idx = latexModule->classCO->currentIndex();
2273 string const classname = classes_model_.getIDString(idx);
2274 bp_.setBaseClass(classname);
2278 modulesToParams(bp_);
2281 if (mathsModule->amsautoCB->isChecked())
2282 bp_.use_amsmath = BufferParams::package_auto;
2284 if (mathsModule->amsCB->isChecked())
2285 bp_.use_amsmath = BufferParams::package_on;
2287 bp_.use_amsmath = BufferParams::package_off;
2289 if (mathsModule->esintautoCB->isChecked())
2290 bp_.use_esint = BufferParams::package_auto;
2292 if (mathsModule->esintCB->isChecked())
2293 bp_.use_esint = BufferParams::package_on;
2295 bp_.use_esint = BufferParams::package_off;
2297 if (mathsModule->mhchemautoCB->isChecked())
2298 bp_.use_mhchem = BufferParams::package_auto;
2300 if (mathsModule->mhchemCB->isChecked())
2301 bp_.use_mhchem = BufferParams::package_on;
2303 bp_.use_mhchem = BufferParams::package_off;
2305 if (mathsModule->mathdotsautoCB->isChecked())
2306 bp_.use_mathdots = BufferParams::package_auto;
2308 if (mathsModule->mathdotsCB->isChecked())
2309 bp_.use_mathdots = BufferParams::package_on;
2311 bp_.use_mathdots = BufferParams::package_off;
2315 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2316 bp_.pagestyle = "default";
2318 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2319 for (size_t i = 0; i != pagestyles.size(); ++i)
2320 if (pagestyles[i].second == style_gui)
2321 bp_.pagestyle = pagestyles[i].first;
2325 switch (textLayoutModule->lspacingCO->currentIndex()) {
2327 bp_.spacing().set(Spacing::Single);
2330 bp_.spacing().set(Spacing::Onehalf);
2333 bp_.spacing().set(Spacing::Double);
2336 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2338 bp_.spacing().set(Spacing::Single);
2340 bp_.spacing().set(Spacing::Other, s);
2345 if (textLayoutModule->twoColumnCB->isChecked())
2350 if (textLayoutModule->indentRB->isChecked()) {
2351 // if paragraphs are separated by an indentation
2352 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2353 switch (textLayoutModule->indentCO->currentIndex()) {
2355 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2358 HSpace indent = HSpace(
2359 widgetsToLength(textLayoutModule->indentLE,
2360 textLayoutModule->indentLengthCO)
2362 bp_.setIndentation(indent);
2366 // this should never happen
2367 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2371 // if paragraphs are separated by a skip
2372 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2373 switch (textLayoutModule->skipCO->currentIndex()) {
2375 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2378 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2381 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2386 widgetsToLength(textLayoutModule->skipLE,
2387 textLayoutModule->skipLengthCO)
2393 // this should never happen
2394 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2400 fromqstr(latexModule->optionsLE->text());
2402 bp_.use_default_options =
2403 latexModule->defaultOptionsCB->isChecked();
2405 if (latexModule->childDocGB->isChecked())
2407 fromqstr(latexModule->childDocLE->text());
2409 bp_.master = string();
2412 bp_.clearIncludedChildren();
2413 if (masterChildModule->includeonlyRB->isChecked()) {
2414 list<string>::const_iterator it = includeonlys_.begin();
2415 for (; it != includeonlys_.end() ; ++it) {
2416 bp_.addIncludedChildren(*it);
2419 bp_.maintain_unincluded_children =
2420 masterChildModule->maintainAuxCB->isChecked();
2423 bp_.float_placement = floatModule->get();
2426 // text should have passed validation
2427 bp_.listings_params =
2428 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2431 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2432 outputModule->defaultFormatCO->currentIndex()).toString());
2434 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2435 bp_.useNonTeXFonts = nontexfonts;
2437 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2438 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2440 int mathfmt = outputModule->mathoutCB->currentIndex();
2443 BufferParams::MathOutput const mo =
2444 static_cast<BufferParams::MathOutput>(mathfmt);
2445 bp_.html_math_output = mo;
2446 bp_.html_be_strict = outputModule->strictCB->isChecked();
2447 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2451 if (fontModule->fontsRomanCO->currentIndex() == 0)
2452 bp_.fonts_roman = "default";
2455 fromqstr(fontModule->fontsRomanCO->currentText());
2457 if (fontModule->fontsSansCO->currentIndex() == 0)
2458 bp_.fonts_sans = "default";
2461 fromqstr(fontModule->fontsSansCO->currentText());
2463 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
2464 bp_.fonts_typewriter = "default";
2466 bp_.fonts_typewriter =
2467 fromqstr(fontModule->fontsTypewriterCO->currentText());
2470 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
2473 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
2475 bp_.fonts_typewriter =
2476 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
2479 if (fontModule->fontencCO->currentIndex() == 0)
2480 bp_.fontenc = "global";
2481 else if (fontModule->fontencCO->currentIndex() == 1)
2482 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2483 else if (fontModule->fontencCO->currentIndex() == 2)
2484 bp_.fontenc = "default";
2487 fromqstr(fontModule->cjkFontLE->text());
2489 bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2491 bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2493 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2495 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2498 bp_.fonts_default_family = "default";
2500 bp_.fonts_default_family = GuiDocument::fontfamilies[
2501 fontModule->fontsDefaultCO->currentIndex()];
2503 if (fontModule->fontsizeCO->currentIndex() == 0)
2504 bp_.fontsize = "default";
2507 fromqstr(fontModule->fontsizeCO->currentText());
2510 bp_.papersize = PAPER_SIZE(
2511 pageLayoutModule->papersizeCO->currentIndex());
2513 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2514 pageLayoutModule->paperwidthUnitCO);
2516 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2517 pageLayoutModule->paperheightUnitCO);
2519 if (pageLayoutModule->facingPagesCB->isChecked())
2520 bp_.sides = TwoSides;
2522 bp_.sides = OneSide;
2524 if (pageLayoutModule->landscapeRB->isChecked())
2525 bp_.orientation = ORIENTATION_LANDSCAPE;
2527 bp_.orientation = ORIENTATION_PORTRAIT;
2530 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2532 Ui::MarginsUi const * m = marginsModule;
2534 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2535 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2536 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2537 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2538 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2539 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2540 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2541 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2544 branchesModule->apply(bp_);
2547 PDFOptions & pdf = bp_.pdfoptions();
2548 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2549 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2550 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2551 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2552 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2554 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2555 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2556 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2557 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2559 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2560 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2561 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2562 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2564 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2565 if (pdfSupportModule->fullscreenCB->isChecked())
2566 pdf.pagemode = pdf.pagemode_fullscreen;
2568 pdf.pagemode.clear();
2569 pdf.quoted_options = pdf.quoted_options_check(
2570 fromqstr(pdfSupportModule->optionsLE->text()));
2574 void GuiDocument::paramsToDialog()
2576 // set the default unit
2577 Length::UNIT const defaultUnit = Length::defaultUnit();
2580 preambleModule->update(bp_, id());
2581 localLayout->update(bp_, id());
2584 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2585 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2588 biblioModule->citeDefaultRB->setChecked(
2589 bp_.citeEngine() == ENGINE_BASIC);
2591 biblioModule->citeNatbibRB->setChecked(
2592 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2593 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2595 biblioModule->citeStyleCO->setCurrentIndex(
2596 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2598 biblioModule->citeJurabibRB->setChecked(
2599 bp_.citeEngine() == ENGINE_JURABIB);
2601 biblioModule->bibtopicCB->setChecked(
2606 split(bp_.bibtex_command, command, ' ');
2608 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2610 biblioModule->bibtexCO->setCurrentIndex(bpos);
2611 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2613 // We reset to default if we do not know the specified compiler
2614 // This is for security reasons
2615 biblioModule->bibtexCO->setCurrentIndex(
2616 biblioModule->bibtexCO->findData(toqstr("default")));
2617 biblioModule->bibtexOptionsED->clear();
2619 biblioModule->bibtexOptionsED->setEnabled(
2620 biblioModule->bibtexCO->currentIndex() != 0);
2623 indicesModule->update(bp_);
2625 // language & quotes
2626 int const pos = langModule->languageCO->findData(toqstr(
2627 bp_.language->lang()));
2628 langModule->languageCO->setCurrentIndex(pos);
2630 langModule->quoteStyleCO->setCurrentIndex(
2631 bp_.quotes_language);
2633 bool default_enc = true;
2634 if (bp_.inputenc != "auto") {
2635 default_enc = false;
2636 if (bp_.inputenc == "default") {
2637 langModule->encodingCO->setCurrentIndex(0);
2640 Encodings::const_iterator it = encodings.begin();
2641 Encodings::const_iterator const end = encodings.end();
2642 for (; it != end; ++it) {
2643 if (it->latexName() == bp_.inputenc) {
2644 enc_gui = it->guiName();
2648 int const i = langModule->encodingCO->findText(
2651 langModule->encodingCO->setCurrentIndex(i);
2653 // unknown encoding. Set to default.
2657 langModule->defaultencodingRB->setChecked(default_enc);
2658 langModule->otherencodingRB->setChecked(!default_enc);
2660 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2662 langModule->languagePackageCO->setCurrentIndex(
2663 langModule->languagePackageCO->findData("custom"));
2664 langModule->languagePackageED->setText(toqstr(bp_.lang_package));
2666 langModule->languagePackageCO->setCurrentIndex(p);
2667 langModule->languagePackageED->clear();
2671 if (bp_.isfontcolor) {
2672 colorModule->fontColorPB->setStyleSheet(
2673 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2675 set_fontcolor = bp_.fontcolor;
2676 is_fontcolor = bp_.isfontcolor;
2678 colorModule->noteFontColorPB->setStyleSheet(
2679 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2680 set_notefontcolor = bp_.notefontcolor;
2682 if (bp_.isbackgroundcolor) {
2683 colorModule->backgroundPB->setStyleSheet(
2684 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2686 set_backgroundcolor = bp_.backgroundcolor;
2687 is_backgroundcolor = bp_.isbackgroundcolor;
2689 colorModule->boxBackgroundPB->setStyleSheet(
2690 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2691 set_boxbgcolor = bp_.boxbgcolor;
2694 int const min_toclevel = documentClass().min_toclevel();
2695 int const max_toclevel = documentClass().max_toclevel();
2696 if (documentClass().hasTocLevels()) {
2697 numberingModule->setEnabled(true);
2698 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2699 numberingModule->depthSL->setMaximum(max_toclevel);
2700 numberingModule->depthSL->setValue(bp_.secnumdepth);
2701 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2702 numberingModule->tocSL->setMaximum(max_toclevel);
2703 numberingModule->tocSL->setValue(bp_.tocdepth);
2706 numberingModule->setEnabled(false);
2707 numberingModule->tocTW->clear();
2711 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2712 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2713 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2714 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2715 bulletsModule->init();
2718 int nitem = findToken(tex_graphics, bp_.graphics_driver);
2720 latexModule->psdriverCO->setCurrentIndex(nitem);
2723 mathsModule->amsCB->setChecked(
2724 bp_.use_amsmath == BufferParams::package_on);
2725 mathsModule->amsautoCB->setChecked(
2726 bp_.use_amsmath == BufferParams::package_auto);
2728 mathsModule->esintCB->setChecked(
2729 bp_.use_esint == BufferParams::package_on);
2730 mathsModule->esintautoCB->setChecked(
2731 bp_.use_esint == BufferParams::package_auto);
2733 mathsModule->mhchemCB->setChecked(
2734 bp_.use_mhchem == BufferParams::package_on);
2735 mathsModule->mhchemautoCB->setChecked(
2736 bp_.use_mhchem == BufferParams::package_auto);
2738 mathsModule->mathdotsCB->setChecked(
2739 bp_.use_mathdots == BufferParams::package_on);
2740 mathsModule->mathdotsautoCB->setChecked(
2741 bp_.use_mathdots == BufferParams::package_auto);
2743 switch (bp_.spacing().getSpace()) {
2744 case Spacing::Other: nitem = 3; break;
2745 case Spacing::Double: nitem = 2; break;
2746 case Spacing::Onehalf: nitem = 1; break;
2747 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2751 string const & layoutID = bp_.baseClassID();
2752 setLayoutComboByIDString(layoutID);
2754 updatePagestyle(documentClass().opt_pagestyle(),
2757 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2758 if (bp_.spacing().getSpace() == Spacing::Other) {
2759 doubleToWidget(textLayoutModule->lspacingLE,
2760 bp_.spacing().getValueAsString());
2764 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2765 textLayoutModule->indentRB->setChecked(true);
2766 string indentation = bp_.getIndentation().asLyXCommand();
2768 if (indentation != "default") {
2769 lengthToWidgets(textLayoutModule->indentLE,
2770 textLayoutModule->indentLengthCO,
2771 indentation, defaultUnit);
2774 textLayoutModule->indentCO->setCurrentIndex(indent);
2777 textLayoutModule->skipRB->setChecked(true);
2779 switch (bp_.getDefSkip().kind()) {
2780 case VSpace::SMALLSKIP:
2783 case VSpace::MEDSKIP:
2786 case VSpace::BIGSKIP:
2789 case VSpace::LENGTH:
2792 string const length = bp_.getDefSkip().asLyXCommand();
2793 lengthToWidgets(textLayoutModule->skipLE,
2794 textLayoutModule->skipLengthCO,
2795 length, defaultUnit);
2802 textLayoutModule->skipCO->setCurrentIndex(skip);
2806 textLayoutModule->twoColumnCB->setChecked(
2809 if (!bp_.options.empty()) {
2810 latexModule->optionsLE->setText(
2811 toqstr(bp_.options));
2813 latexModule->optionsLE->setText(QString());
2817 latexModule->defaultOptionsCB->setChecked(
2818 bp_.use_default_options);
2819 updateSelectedModules();
2820 selectionManager->updateProvidedModules(
2821 bp_.baseClass()->providedModules());
2822 selectionManager->updateExcludedModules(
2823 bp_.baseClass()->excludedModules());
2825 if (!documentClass().options().empty()) {
2826 latexModule->defaultOptionsLE->setText(
2827 toqstr(documentClass().options()));
2829 latexModule->defaultOptionsLE->setText(
2830 toqstr(_("[No options predefined]")));
2833 latexModule->defaultOptionsLE->setEnabled(
2834 bp_.use_default_options
2835 && !documentClass().options().empty());
2837 latexModule->defaultOptionsCB->setEnabled(
2838 !documentClass().options().empty());
2840 if (!bp_.master.empty()) {
2841 latexModule->childDocGB->setChecked(true);
2842 latexModule->childDocLE->setText(
2843 toqstr(bp_.master));
2845 latexModule->childDocLE->setText(QString());
2846 latexModule->childDocGB->setChecked(false);
2850 if (!bufferview() || !buffer().hasChildren()) {
2851 masterChildModule->childrenTW->clear();
2852 includeonlys_.clear();
2853 docPS->showPanel(qt_("Child Documents"), false);
2854 if (docPS->isCurrentPanel(qt_("Child Documents")))
2855 docPS->setCurrentPanel(qt_("Document Class"));
2857 docPS->showPanel(qt_("Child Documents"), true);
2858 masterChildModule->setEnabled(true);
2859 includeonlys_ = bp_.getIncludedChildren();
2860 updateIncludeonlys();
2862 masterChildModule->maintainAuxCB->setChecked(
2863 bp_.maintain_unincluded_children);
2866 floatModule->set(bp_.float_placement);
2869 // break listings_params to multiple lines
2871 InsetListingsParams(bp_.listings_params).separatedParams();
2872 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2875 // update combobox with formats
2876 updateDefaultFormat();
2877 int index = outputModule->defaultFormatCO->findData(toqstr(
2878 bp_.default_output_format));
2879 // set to default if format is not found
2882 outputModule->defaultFormatCO->setCurrentIndex(index);
2883 bool const os_fonts_available =
2884 bp_.baseClass()->outputType() == lyx::LATEX
2885 && LaTeXFeatures::isAvailable("fontspec");
2886 fontModule->osFontsCB->setEnabled(os_fonts_available);
2887 fontModule->osFontsCB->setChecked(
2888 os_fonts_available && bp_.useNonTeXFonts);
2890 outputModule->outputsyncCB->setChecked(bp_.output_sync);
2891 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2893 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2894 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2895 outputModule->strictCB->setChecked(bp_.html_be_strict);
2898 updateFontsize(documentClass().opt_fontsize(),
2901 if (bp_.useNonTeXFonts && os_fonts_available) {
2902 fontModule->fontencLA->setEnabled(false);
2903 fontModule->fontencCO->setEnabled(false);
2904 fontModule->fontencLE->setEnabled(false);
2905 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2906 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fonts_roman)) {
2907 fontModule->fontsRomanCO->setCurrentIndex(i);
2912 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2913 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fonts_sans)) {
2914 fontModule->fontsSansCO->setCurrentIndex(i);
2918 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2919 if (fontModule->fontsTypewriterCO->itemText(i) ==
2920 toqstr(bp_.fonts_typewriter)) {
2921 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2926 fontModule->fontencLA->setEnabled(true);
2927 fontModule->fontencCO->setEnabled(true);
2928 fontModule->fontencLE->setEnabled(true);
2929 int n = findToken(tex_fonts_roman, bp_.fonts_roman);
2931 fontModule->fontsRomanCO->setCurrentIndex(n);
2935 n = findToken(tex_fonts_sans, bp_.fonts_sans);
2937 fontModule->fontsSansCO->setCurrentIndex(n);
2941 n = findToken(tex_fonts_monospaced, bp_.fonts_typewriter);
2943 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2948 if (!bp_.fonts_cjk.empty())
2949 fontModule->cjkFontLE->setText(
2950 toqstr(bp_.fonts_cjk));
2952 fontModule->cjkFontLE->setText(QString());
2954 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
2955 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
2956 fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
2957 fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
2959 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
2961 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2963 if (bp_.fontenc == "global") {
2964 fontModule->fontencCO->setCurrentIndex(0);
2965 fontModule->fontencLE->setEnabled(false);
2966 } else if (bp_.fontenc == "default") {
2967 fontModule->fontencCO->setCurrentIndex(2);
2968 fontModule->fontencLE->setEnabled(false);
2970 fontModule->fontencCO->setCurrentIndex(1);
2971 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2975 bool const extern_geometry =
2976 documentClass().provides("geometry");
2977 int const psize = bp_.papersize;
2978 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2979 setCustomPapersize(!extern_geometry && psize == 1);
2980 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2982 bool const landscape =
2983 bp_.orientation == ORIENTATION_LANDSCAPE;
2984 pageLayoutModule->landscapeRB->setChecked(landscape);
2985 pageLayoutModule->portraitRB->setChecked(!landscape);
2986 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2987 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2989 pageLayoutModule->facingPagesCB->setChecked(
2990 bp_.sides == TwoSides);
2992 lengthToWidgets(pageLayoutModule->paperwidthLE,
2993 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2994 lengthToWidgets(pageLayoutModule->paperheightLE,
2995 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2998 Ui::MarginsUi * m = marginsModule;
3002 lengthToWidgets(m->topLE, m->topUnit,
3003 bp_.topmargin, defaultUnit);
3005 lengthToWidgets(m->bottomLE, m->bottomUnit,
3006 bp_.bottommargin, defaultUnit);
3008 lengthToWidgets(m->innerLE, m->innerUnit,
3009 bp_.leftmargin, defaultUnit);
3011 lengthToWidgets(m->outerLE, m->outerUnit,
3012 bp_.rightmargin, defaultUnit);
3014 lengthToWidgets(m->headheightLE, m->headheightUnit,
3015 bp_.headheight, defaultUnit);
3017 lengthToWidgets(m->headsepLE, m->headsepUnit,
3018 bp_.headsep, defaultUnit);
3020 lengthToWidgets(m->footskipLE, m->footskipUnit,
3021 bp_.footskip, defaultUnit);
3023 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3024 bp_.columnsep, defaultUnit);
3027 updateUnknownBranches();
3028 branchesModule->update(bp_);
3031 PDFOptions const & pdf = bp_.pdfoptions();
3032 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3033 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3034 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3035 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3036 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3038 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3039 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3040 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3042 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3044 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3045 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3046 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3047 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3049 nn = findToken(backref_opts, pdf.backref);
3051 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3053 pdfSupportModule->fullscreenCB->setChecked
3054 (pdf.pagemode == pdf.pagemode_fullscreen);
3056 pdfSupportModule->optionsLE->setText(
3057 toqstr(pdf.quoted_options));
3059 // Make sure that the bc is in the INITIAL state
3060 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3063 // clear changed branches cache
3064 changedBranches_.clear();
3068 void GuiDocument::saveDocDefault()
3070 // we have to apply the params first
3076 void GuiDocument::updateAvailableModules()
3078 modules_av_model_.clear();
3079 list<modInfoStruct> const & modInfoList = getModuleInfo();
3080 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3081 list<modInfoStruct>::const_iterator men = modInfoList.end();
3082 for (int i = 0; mit != men; ++mit, ++i)
3083 modules_av_model_.insertRow(i, mit->name, mit->id,
3088 void GuiDocument::updateSelectedModules()
3090 modules_sel_model_.clear();
3091 list<modInfoStruct> const selModList = getSelectedModules();
3092 list<modInfoStruct>::const_iterator mit = selModList.begin();
3093 list<modInfoStruct>::const_iterator men = selModList.end();
3094 for (int i = 0; mit != men; ++mit, ++i)
3095 modules_sel_model_.insertRow(i, mit->name, mit->id,
3100 void GuiDocument::updateIncludeonlys()
3102 masterChildModule->childrenTW->clear();
3103 QString const no = qt_("No");
3104 QString const yes = qt_("Yes");
3106 if (includeonlys_.empty()) {
3107 masterChildModule->includeallRB->setChecked(true);
3108 masterChildModule->childrenTW->setEnabled(false);
3109 masterChildModule->maintainAuxCB->setEnabled(false);
3111 masterChildModule->includeonlyRB->setChecked(true);
3112 masterChildModule->childrenTW->setEnabled(true);
3113 masterChildModule->maintainAuxCB->setEnabled(true);
3115 QTreeWidgetItem * item = 0;
3116 ListOfBuffers children = buffer().getChildren();
3117 ListOfBuffers::const_iterator it = children.begin();
3118 ListOfBuffers::const_iterator end = children.end();
3119 bool has_unincluded = false;
3120 bool all_unincluded = true;
3121 for (; it != end; ++it) {
3122 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3125 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3126 from_utf8(buffer().filePath())));
3127 item->setText(0, toqstr(name));
3128 item->setText(1, isChildIncluded(name) ? yes : no);
3129 if (!isChildIncluded(name))
3130 has_unincluded = true;
3132 all_unincluded = false;
3134 // Both if all childs are included and if none is included
3135 // is equal to "include all" (i.e., ommit \includeonly).
3136 // Thus, reset the GUI.
3137 if (!has_unincluded || all_unincluded) {
3138 masterChildModule->includeallRB->setChecked(true);
3139 masterChildModule->childrenTW->setEnabled(false);
3140 includeonlys_.clear();
3142 // If all are included, we need to update again.
3143 if (!has_unincluded)
3144 updateIncludeonlys();
3148 void GuiDocument::updateContents()
3150 // Nothing to do here as the document settings is not cursor dependant.
3155 void GuiDocument::useClassDefaults()
3157 if (applyPB->isEnabled()) {
3158 int const ret = Alert::prompt(_("Unapplied changes"),
3159 _("Some changes in the dialog were not yet applied.\n"
3160 "If you do not apply now, they will be lost after this action."),
3161 1, 1, _("&Apply"), _("&Dismiss"));
3166 int idx = latexModule->classCO->currentIndex();
3167 string const classname = classes_model_.getIDString(idx);
3168 if (!bp_.setBaseClass(classname)) {
3169 Alert::error(_("Error"), _("Unable to set document class."));
3172 bp_.useClassDefaults();
3177 void GuiDocument::setLayoutComboByIDString(string const & idString)
3179 int idx = classes_model_.findIDString(idString);
3181 Alert::warning(_("Can't set layout!"),
3182 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3184 latexModule->classCO->setCurrentIndex(idx);
3188 bool GuiDocument::isValid()
3191 validateListingsParameters().isEmpty() &&
3192 localLayout->isValid() &&
3194 // if we're asking for skips between paragraphs
3195 !textLayoutModule->skipRB->isChecked() ||
3196 // then either we haven't chosen custom
3197 textLayoutModule->skipCO->currentIndex() != 3 ||
3198 // or else a length has been given
3199 !textLayoutModule->skipLE->text().isEmpty()
3202 // if we're asking for indentation
3203 !textLayoutModule->indentRB->isChecked() ||
3204 // then either we haven't chosen custom
3205 textLayoutModule->indentCO->currentIndex() != 1 ||
3206 // or else a length has been given
3207 !textLayoutModule->indentLE->text().isEmpty()
3212 char const * const GuiDocument::fontfamilies[5] = {
3213 "default", "rmdefault", "sfdefault", "ttdefault", ""
3217 char const * GuiDocument::fontfamilies_gui[5] = {
3218 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3222 bool GuiDocument::initialiseParams(string const &)
3224 BufferView const * view = bufferview();
3226 bp_ = BufferParams();
3230 bp_ = view->buffer().params();
3232 updateAvailableModules();
3233 //FIXME It'd be nice to make sure here that the selected
3234 //modules are consistent: That required modules are actually
3235 //selected, and that we don't have conflicts. If so, we could
3236 //at least pop up a warning.
3242 void GuiDocument::clearParams()
3244 bp_ = BufferParams();
3248 BufferId GuiDocument::id() const
3250 BufferView const * const view = bufferview();
3251 return view? &view->buffer() : 0;
3255 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3257 return moduleNames_;
3261 list<GuiDocument::modInfoStruct> const
3262 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3264 LayoutModuleList::const_iterator it = mods.begin();
3265 LayoutModuleList::const_iterator end = mods.end();
3266 list<modInfoStruct> mInfo;
3267 for (; it != end; ++it) {
3270 LyXModule const * const mod = theModuleList[*it];
3273 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3275 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3282 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3284 return makeModuleInfo(params().getModules());
3288 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3290 return makeModuleInfo(params().baseClass()->providedModules());
3294 DocumentClass const & GuiDocument::documentClass() const
3296 return bp_.documentClass();
3300 static void dispatch_bufferparams(Dialog const & dialog,
3301 BufferParams const & bp, FuncCode lfun)
3304 ss << "\\begin_header\n";
3306 ss << "\\end_header\n";
3307 dialog.dispatch(FuncRequest(lfun, ss.str()));
3311 void GuiDocument::dispatchParams()
3313 // This must come first so that a language change is correctly noticed
3316 // Apply the BufferParams. Note that this will set the base class
3317 // and then update the buffer's layout.
3318 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3320 if (!params().master.empty()) {
3321 FileName const master_file = support::makeAbsPath(params().master,
3322 support::onlyPath(buffer().absFileName()));
3323 if (isLyXFileName(master_file.absFileName())) {
3324 Buffer * master = checkAndLoadLyXFile(master_file);
3326 if (master->isChild(const_cast<Buffer *>(&buffer())))
3327 const_cast<Buffer &>(buffer()).setParent(master);
3329 Alert::warning(_("Assigned master does not include this file"),
3330 bformat(_("You must include this file in the document\n"
3331 "'%1$s' in order to use the master document\n"
3332 "feature."), from_utf8(params().master)));
3334 Alert::warning(_("Could not load master"),
3335 bformat(_("The master document '%1$s'\n"
3336 "could not be loaded."),
3337 from_utf8(params().master)));
3341 // Generate the colours requested by each new branch.
3342 BranchList & branchlist = params().branchlist();
3343 if (!branchlist.empty()) {
3344 BranchList::const_iterator it = branchlist.begin();
3345 BranchList::const_iterator const end = branchlist.end();
3346 for (; it != end; ++it) {
3347 docstring const & current_branch = it->branch();
3348 Branch const * branch = branchlist.find(current_branch);
3349 string const x11hexname = X11hexname(branch->color());
3350 // display the new color
3351 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3352 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3355 // Open insets of selected branches, close deselected ones
3356 dispatch(FuncRequest(LFUN_INSET_FORALL,
3357 "Branch inset-toggle assign"));
3359 // rename branches in the document
3360 executeBranchRenaming();
3361 // and clear changed branches cache
3362 changedBranches_.clear();
3364 // Generate the colours requested by indices.
3365 IndicesList & indiceslist = params().indiceslist();
3366 if (!indiceslist.empty()) {
3367 IndicesList::const_iterator it = indiceslist.begin();
3368 IndicesList::const_iterator const end = indiceslist.end();
3369 for (; it != end; ++it) {
3370 docstring const & current_index = it->shortcut();
3371 Index const * index = indiceslist.findShortcut(current_index);
3372 string const x11hexname = X11hexname(index->color());
3373 // display the new color
3374 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3375 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3379 // If we used an LFUN, we would not need these two lines:
3380 BufferView * bv = const_cast<BufferView *>(bufferview());
3381 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3385 void GuiDocument::setLanguage() const
3387 Language const * const newL = bp_.language;
3388 if (buffer().params().language == newL)
3391 string const & lang_name = newL->lang();
3392 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3396 void GuiDocument::saveAsDefault() const
3398 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3402 bool GuiDocument::isFontAvailable(string const & font) const
3404 if (font == "default" || font == "cmr"
3405 || font == "cmss" || font == "cmtt")
3406 // these are standard
3408 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3409 return LaTeXFeatures::isAvailable("lmodern");
3410 if (font == "times" || font == "palatino"
3411 || font == "helvet" || font == "courier")
3412 return LaTeXFeatures::isAvailable("psnfss");
3413 if (font == "cmbr" || font == "cmtl")
3414 return LaTeXFeatures::isAvailable("cmbright");
3415 if (font == "utopia")
3416 return LaTeXFeatures::isAvailable("utopia")
3417 || LaTeXFeatures::isAvailable("fourier");
3418 if (font == "beraserif" || font == "berasans"
3419 || font == "beramono")
3420 return LaTeXFeatures::isAvailable("bera");
3421 return LaTeXFeatures::isAvailable(font);
3425 bool GuiDocument::providesOSF(string const & font) const
3427 if (fontModule->osFontsCB->isChecked())
3428 // FIXME: we should check if the fonts really
3429 // have OSF support. But how?
3432 return isFontAvailable("eco");
3433 if (font == "palatino")
3434 return isFontAvailable("mathpazo");
3439 bool GuiDocument::providesSC(string const & font) const
3441 if (fontModule->osFontsCB->isChecked())
3443 if (font == "palatino")
3444 return isFontAvailable("mathpazo");
3445 if (font == "utopia")
3446 return isFontAvailable("fourier");
3451 bool GuiDocument::providesScale(string const & font) const
3453 if (fontModule->osFontsCB->isChecked())
3455 return font == "helvet" || font == "luximono"
3456 || font == "berasans" || font == "beramono";
3460 void GuiDocument::loadModuleInfo()
3462 moduleNames_.clear();
3463 LyXModuleList::const_iterator it = theModuleList.begin();
3464 LyXModuleList::const_iterator end = theModuleList.end();
3465 for (; it != end; ++it) {
3469 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3470 // this is supposed to give us the first sentence of the description
3473 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3474 int const pos = desc.indexOf(".");
3476 desc.truncate(pos + 1);
3477 m.description = desc;
3478 moduleNames_.push_back(m);
3483 void GuiDocument::updateUnknownBranches()
3487 list<docstring> used_branches;
3488 buffer().getUsedBranches(used_branches);
3489 list<docstring>::const_iterator it = used_branches.begin();
3490 QStringList unknown_branches;
3491 for (; it != used_branches.end() ; ++it) {
3492 if (!buffer().params().branchlist().find(*it))
3493 unknown_branches.append(toqstr(*it));
3495 branchesModule->setUnknownBranches(unknown_branches);
3499 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3501 map<docstring, docstring>::iterator it = changedBranches_.begin();
3502 for (; it != changedBranches_.end() ; ++it) {
3503 if (it->second == oldname) {
3504 // branch has already been renamed
3505 it->second = newname;
3510 changedBranches_[oldname] = newname;
3514 void GuiDocument::executeBranchRenaming() const
3516 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3517 for (; it != changedBranches_.end() ; ++it) {
3518 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3519 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3524 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3527 } // namespace frontend
3530 #include "moc_GuiDocument.cpp"