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"));
1051 biblioModule = new UiWidget<Ui::BiblioUi>;
1052 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1053 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1054 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1055 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1056 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1057 this, SLOT(change_adaptor()));
1058 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1059 this, SLOT(change_adaptor()));
1060 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1061 this, SLOT(change_adaptor()));
1062 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1063 this, SLOT(change_adaptor()));
1064 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1065 this, SLOT(change_adaptor()));
1066 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1067 this, SLOT(bibtexChanged(int)));
1068 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
1069 this, SLOT(change_adaptor()));
1071 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1072 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1073 biblioModule->citeStyleCO->setCurrentIndex(0);
1075 // NOTE: we do not provide "custom" here for security reasons!
1076 biblioModule->bibtexCO->clear();
1077 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1078 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1079 it != lyxrc.bibtex_alternatives.end(); ++it) {
1080 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1081 biblioModule->bibtexCO->addItem(command, command);
1086 indicesModule = new GuiIndices;
1087 connect(indicesModule, SIGNAL(changed()),
1088 this, SLOT(change_adaptor()));
1092 mathsModule = new UiWidget<Ui::MathsUi>;
1093 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1094 mathsModule->amsCB, SLOT(setDisabled(bool)));
1095 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1096 mathsModule->esintCB, SLOT(setDisabled(bool)));
1097 connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1098 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1099 connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1100 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1102 connect(mathsModule->amsCB, SIGNAL(clicked()),
1103 this, SLOT(change_adaptor()));
1104 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1105 this, SLOT(change_adaptor()));
1106 connect(mathsModule->esintCB, SIGNAL(clicked()),
1107 this, SLOT(change_adaptor()));
1108 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1109 this, SLOT(change_adaptor()));
1110 connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1111 this, SLOT(change_adaptor()));
1112 connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1113 this, SLOT(change_adaptor()));
1114 connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1115 this, SLOT(change_adaptor()));
1116 connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1117 this, SLOT(change_adaptor()));
1121 latexModule = new UiWidget<Ui::LaTeXUi>;
1122 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1123 this, SLOT(change_adaptor()));
1124 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1125 this, SLOT(change_adaptor()));
1126 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1127 this, SLOT(change_adaptor()));
1128 connect(latexModule->classCO, SIGNAL(activated(int)),
1129 this, SLOT(classChanged()));
1130 connect(latexModule->classCO, SIGNAL(activated(int)),
1131 this, SLOT(change_adaptor()));
1132 connect(latexModule->layoutPB, SIGNAL(clicked()),
1133 this, SLOT(browseLayout()));
1134 connect(latexModule->layoutPB, SIGNAL(clicked()),
1135 this, SLOT(change_adaptor()));
1136 connect(latexModule->childDocGB, SIGNAL(clicked()),
1137 this, SLOT(change_adaptor()));
1138 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1139 this, SLOT(change_adaptor()));
1140 connect(latexModule->childDocPB, SIGNAL(clicked()),
1141 this, SLOT(browseMaster()));
1142 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1143 this, SLOT(change_adaptor()));
1144 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1145 this, SLOT(change_adaptor()));
1147 // postscript drivers
1148 for (int n = 0; tex_graphics[n][0]; ++n) {
1149 QString enc = qt_(tex_graphics_gui[n]);
1150 latexModule->psdriverCO->addItem(enc);
1153 latexModule->classCO->setModel(&classes_model_);
1154 LayoutFileList const & bcl = LayoutFileList::get();
1155 vector<LayoutFileIndex> classList = bcl.classList();
1156 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1158 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1159 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1160 for (int i = 0; cit != cen; ++cit, ++i) {
1161 LayoutFile const & tc = bcl[*cit];
1162 docstring item = (tc.isTeXClassAvailable()) ?
1163 from_utf8(tc.description()) :
1164 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1165 classes_model_.insertRow(i, toqstr(item), *cit);
1170 branchesModule = new GuiBranches;
1171 connect(branchesModule, SIGNAL(changed()),
1172 this, SLOT(change_adaptor()));
1173 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1174 this, SLOT(branchesRename(docstring const &, docstring const &)));
1175 updateUnknownBranches();
1179 preambleModule = new PreambleModule;
1180 connect(preambleModule, SIGNAL(changed()),
1181 this, SLOT(change_adaptor()));
1183 localLayout = new LocalLayout;
1184 connect(localLayout, SIGNAL(changed()),
1185 this, SLOT(change_adaptor()));
1189 bulletsModule = new BulletsModule;
1190 connect(bulletsModule, SIGNAL(changed()),
1191 this, SLOT(change_adaptor()));
1195 modulesModule = new UiWidget<Ui::ModulesUi>;
1196 modulesModule->availableLV->header()->setVisible(false);
1198 new ModuleSelectionManager(modulesModule->availableLV,
1199 modulesModule->selectedLV,
1200 modulesModule->addPB, modulesModule->deletePB,
1201 modulesModule->upPB, modulesModule->downPB,
1202 availableModel(), selectedModel(), this);
1203 connect(selectionManager, SIGNAL(updateHook()),
1204 this, SLOT(updateModuleInfo()));
1205 connect(selectionManager, SIGNAL(updateHook()),
1206 this, SLOT(change_adaptor()));
1207 connect(selectionManager, SIGNAL(selectionChanged()),
1208 this, SLOT(modulesChanged()));
1212 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1213 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1214 this, SLOT(change_adaptor()));
1215 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1216 this, SLOT(change_adaptor()));
1217 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1218 this, SLOT(change_adaptor()));
1219 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1220 this, SLOT(change_adaptor()));
1221 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1222 this, SLOT(change_adaptor()));
1223 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1224 this, SLOT(change_adaptor()));
1225 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1226 this, SLOT(change_adaptor()));
1227 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1228 this, SLOT(change_adaptor()));
1229 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1230 this, SLOT(change_adaptor()));
1231 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1232 this, SLOT(change_adaptor()));
1233 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1234 this, SLOT(change_adaptor()));
1235 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1236 this, SLOT(change_adaptor()));
1237 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1238 this, SLOT(change_adaptor()));
1239 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1240 this, SLOT(change_adaptor()));
1241 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1242 this, SLOT(change_adaptor()));
1243 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1244 this, SLOT(change_adaptor()));
1246 for (int i = 0; backref_opts[i][0]; ++i)
1247 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1251 floatModule = new FloatPlacement;
1252 connect(floatModule, SIGNAL(changed()),
1253 this, SLOT(change_adaptor()));
1257 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1258 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1259 this, SLOT(change_adaptor()));
1260 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1261 this, SLOT(change_adaptor()));
1262 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1263 this, SLOT(setListingsMessage()));
1264 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1265 this, SLOT(setListingsMessage()));
1266 listingsModule->listingsTB->setPlainText(
1267 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1271 docPS->addPanel(latexModule, qt_("Document Class"));
1272 docPS->addPanel(masterChildModule, qt_("Child Documents"));
1273 docPS->addPanel(modulesModule, qt_("Modules"));
1274 docPS->addPanel(localLayout, qt_("Local Layout"));
1275 docPS->addPanel(fontModule, qt_("Fonts"));
1276 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1277 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1278 docPS->addPanel(marginsModule, qt_("Page Margins"));
1279 docPS->addPanel(langModule, qt_("Language"));
1280 docPS->addPanel(colorModule, qt_("Colors"));
1281 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1282 docPS->addPanel(biblioModule, qt_("Bibliography"));
1283 docPS->addPanel(indicesModule, qt_("Indexes"));
1284 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1285 docPS->addPanel(mathsModule, qt_("Math Options"));
1286 docPS->addPanel(floatModule, qt_("Float Placement"));
1287 docPS->addPanel(listingsModule, qt_("Listings"));
1288 docPS->addPanel(bulletsModule, qt_("Bullets"));
1289 docPS->addPanel(branchesModule, qt_("Branches"));
1290 docPS->addPanel(outputModule, qt_("Output"));
1291 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1292 docPS->setCurrentPanel(qt_("Document Class"));
1293 // FIXME: hack to work around resizing bug in Qt >= 4.2
1294 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1295 #if QT_VERSION >= 0x040200
1296 docPS->updateGeometry();
1301 void GuiDocument::saveDefaultClicked()
1307 void GuiDocument::useDefaultsClicked()
1313 void GuiDocument::change_adaptor()
1319 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1324 string child = fromqstr(item->text(0));
1328 if (std::find(includeonlys_.begin(),
1329 includeonlys_.end(), child) != includeonlys_.end())
1330 includeonlys_.remove(child);
1332 includeonlys_.push_back(child);
1334 updateIncludeonlys();
1339 QString GuiDocument::validateListingsParameters()
1341 // use a cache here to avoid repeated validation
1342 // of the same parameters
1343 static string param_cache;
1344 static QString msg_cache;
1346 if (listingsModule->bypassCB->isChecked())
1349 string params = fromqstr(listingsModule->listingsED->toPlainText());
1350 if (params != param_cache) {
1351 param_cache = params;
1352 msg_cache = toqstr(InsetListingsParams(params).validate());
1358 void GuiDocument::setListingsMessage()
1360 static bool isOK = true;
1361 QString msg = validateListingsParameters();
1362 if (msg.isEmpty()) {
1366 // listingsTB->setTextColor("black");
1367 listingsModule->listingsTB->setPlainText(
1368 qt_("Input listings parameters below. "
1369 "Enter ? for a list of parameters."));
1372 // listingsTB->setTextColor("red");
1373 listingsModule->listingsTB->setPlainText(msg);
1378 void GuiDocument::setLSpacing(int item)
1380 textLayoutModule->lspacingLE->setEnabled(item == 3);
1384 void GuiDocument::setIndent(int item)
1386 bool const enable = (item == 1);
1387 textLayoutModule->indentLE->setEnabled(enable);
1388 textLayoutModule->indentLengthCO->setEnabled(enable);
1389 textLayoutModule->skipLE->setEnabled(false);
1390 textLayoutModule->skipLengthCO->setEnabled(false);
1395 void GuiDocument::enableIndent(bool indent)
1397 textLayoutModule->skipLE->setEnabled(!indent);
1398 textLayoutModule->skipLengthCO->setEnabled(!indent);
1400 setIndent(textLayoutModule->indentCO->currentIndex());
1404 void GuiDocument::setSkip(int item)
1406 bool const enable = (item == 3);
1407 textLayoutModule->skipLE->setEnabled(enable);
1408 textLayoutModule->skipLengthCO->setEnabled(enable);
1413 void GuiDocument::enableSkip(bool skip)
1415 textLayoutModule->indentLE->setEnabled(!skip);
1416 textLayoutModule->indentLengthCO->setEnabled(!skip);
1418 setSkip(textLayoutModule->skipCO->currentIndex());
1422 void GuiDocument::setMargins()
1424 bool const extern_geometry =
1425 documentClass().provides("geometry");
1426 marginsModule->marginCB->setEnabled(!extern_geometry);
1427 if (extern_geometry) {
1428 marginsModule->marginCB->setChecked(false);
1429 setCustomMargins(true);
1431 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1432 setCustomMargins(!bp_.use_geometry);
1437 void GuiDocument::papersizeChanged(int paper_size)
1439 setCustomPapersize(paper_size == 1);
1443 void GuiDocument::setCustomPapersize(bool custom)
1445 pageLayoutModule->paperwidthL->setEnabled(custom);
1446 pageLayoutModule->paperwidthLE->setEnabled(custom);
1447 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1448 pageLayoutModule->paperheightL->setEnabled(custom);
1449 pageLayoutModule->paperheightLE->setEnabled(custom);
1450 pageLayoutModule->paperheightLE->setFocus();
1451 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1455 void GuiDocument::setColSep()
1457 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1461 void GuiDocument::setCustomMargins(bool custom)
1463 marginsModule->topL->setEnabled(!custom);
1464 marginsModule->topLE->setEnabled(!custom);
1465 marginsModule->topUnit->setEnabled(!custom);
1467 marginsModule->bottomL->setEnabled(!custom);
1468 marginsModule->bottomLE->setEnabled(!custom);
1469 marginsModule->bottomUnit->setEnabled(!custom);
1471 marginsModule->innerL->setEnabled(!custom);
1472 marginsModule->innerLE->setEnabled(!custom);
1473 marginsModule->innerUnit->setEnabled(!custom);
1475 marginsModule->outerL->setEnabled(!custom);
1476 marginsModule->outerLE->setEnabled(!custom);
1477 marginsModule->outerUnit->setEnabled(!custom);
1479 marginsModule->headheightL->setEnabled(!custom);
1480 marginsModule->headheightLE->setEnabled(!custom);
1481 marginsModule->headheightUnit->setEnabled(!custom);
1483 marginsModule->headsepL->setEnabled(!custom);
1484 marginsModule->headsepLE->setEnabled(!custom);
1485 marginsModule->headsepUnit->setEnabled(!custom);
1487 marginsModule->footskipL->setEnabled(!custom);
1488 marginsModule->footskipLE->setEnabled(!custom);
1489 marginsModule->footskipUnit->setEnabled(!custom);
1491 bool const enableColSep = !custom &&
1492 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1493 marginsModule->columnsepL->setEnabled(enableColSep);
1494 marginsModule->columnsepLE->setEnabled(enableColSep);
1495 marginsModule->columnsepUnit->setEnabled(enableColSep);
1499 void GuiDocument::changeBackgroundColor()
1501 QColor const & newColor = QColorDialog::getColor(
1502 rgb2qcolor(set_backgroundcolor), asQWidget());
1503 if (!newColor.isValid())
1505 // set the button color and text
1506 colorModule->backgroundPB->setStyleSheet(
1507 colorButtonStyleSheet(newColor));
1508 colorModule->backgroundPB->setText(toqstr("Change..."));
1510 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1511 is_backgroundcolor = true;
1516 void GuiDocument::deleteBackgroundColor()
1518 // set the button color back to default by setting an epmty StyleSheet
1519 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1520 // change button text
1521 colorModule->backgroundPB->setText(toqstr("Default..."));
1522 // save default color (white)
1523 set_backgroundcolor = rgbFromHexName("#ffffff");
1524 is_backgroundcolor = false;
1529 void GuiDocument::changeFontColor()
1531 QColor const & newColor = QColorDialog::getColor(
1532 rgb2qcolor(set_fontcolor), asQWidget());
1533 if (!newColor.isValid())
1535 // set the button color and text
1536 colorModule->fontColorPB->setStyleSheet(
1537 colorButtonStyleSheet(newColor));
1538 colorModule->fontColorPB->setText(toqstr("Change..."));
1540 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1541 is_fontcolor = true;
1546 void GuiDocument::deleteFontColor()
1548 // set the button color back to default by setting an epmty StyleSheet
1549 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1550 // change button text
1551 colorModule->fontColorPB->setText(toqstr("Default..."));
1552 // save default color (black)
1553 set_fontcolor = rgbFromHexName("#000000");
1554 is_fontcolor = false;
1559 void GuiDocument::changeNoteFontColor()
1561 QColor const & newColor = QColorDialog::getColor(
1562 rgb2qcolor(set_notefontcolor), asQWidget());
1563 if (!newColor.isValid())
1565 // set the button color
1566 colorModule->noteFontColorPB->setStyleSheet(
1567 colorButtonStyleSheet(newColor));
1569 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1574 void GuiDocument::deleteNoteFontColor()
1576 // set the button color back to light gray
1577 colorModule->noteFontColorPB->setStyleSheet(
1578 colorButtonStyleSheet(QColor(204, 204, 204, 255)));
1579 // save light gray as the set color
1580 set_notefontcolor = rgbFromHexName("#cccccc");
1585 void GuiDocument::changeBoxBackgroundColor()
1587 QColor const & newColor = QColorDialog::getColor(
1588 rgb2qcolor(set_boxbgcolor), asQWidget());
1589 if (!newColor.isValid())
1591 // set the button color
1592 colorModule->boxBackgroundPB->setStyleSheet(
1593 colorButtonStyleSheet(newColor));
1595 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1600 void GuiDocument::deleteBoxBackgroundColor()
1602 // set the button color back to red
1603 colorModule->boxBackgroundPB->setStyleSheet(
1604 colorButtonStyleSheet(QColor(Qt::red)));
1605 // save red as the set color
1606 set_boxbgcolor = rgbFromHexName("#ff0000");
1611 void GuiDocument::osFontsChanged(bool nontexfonts)
1613 bool const tex_fonts = !nontexfonts;
1615 updateDefaultFormat();
1616 langModule->encodingCO->setEnabled(tex_fonts &&
1617 !langModule->defaultencodingRB->isChecked());
1618 langModule->defaultencodingRB->setEnabled(tex_fonts);
1619 langModule->otherencodingRB->setEnabled(tex_fonts);
1621 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1622 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1623 fontModule->cjkFontLE->setEnabled(tex_fonts);
1624 fontModule->cjkFontLA->setEnabled(tex_fonts);
1627 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1628 bool scaleable = providesScale(font);
1629 fontModule->scaleSansSB->setEnabled(scaleable);
1630 fontModule->scaleSansLA->setEnabled(scaleable);
1632 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1633 scaleable = providesScale(font);
1634 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1635 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1637 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1638 fontModule->fontScCB->setEnabled(providesSC(font));
1639 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1641 fontModule->fontencLA->setEnabled(tex_fonts);
1642 fontModule->fontencCO->setEnabled(tex_fonts);
1644 fontModule->fontencLE->setEnabled(false);
1646 fontencChanged(fontModule->fontencCO->currentIndex());
1650 void GuiDocument::updateFontsize(string const & items, string const & sel)
1652 fontModule->fontsizeCO->clear();
1653 fontModule->fontsizeCO->addItem(qt_("Default"));
1655 for (int n = 0; !token(items,'|',n).empty(); ++n)
1656 fontModule->fontsizeCO->
1657 addItem(toqstr(token(items,'|',n)));
1659 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1660 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1661 fontModule->fontsizeCO->setCurrentIndex(n);
1668 void GuiDocument::updateFontlist()
1670 fontModule->fontsRomanCO->clear();
1671 fontModule->fontsSansCO->clear();
1672 fontModule->fontsTypewriterCO->clear();
1674 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1675 if (fontModule->osFontsCB->isChecked()) {
1676 fontModule->fontsRomanCO->addItem(qt_("Default"));
1677 fontModule->fontsSansCO->addItem(qt_("Default"));
1678 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1680 QFontDatabase fontdb;
1681 QStringList families(fontdb.families());
1682 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1683 fontModule->fontsRomanCO->addItem(*it);
1684 fontModule->fontsSansCO->addItem(*it);
1685 fontModule->fontsTypewriterCO->addItem(*it);
1690 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1691 QString font = qt_(tex_fonts_roman_gui[n]);
1692 if (!isFontAvailable(tex_fonts_roman[n]))
1693 font += qt_(" (not installed)");
1694 fontModule->fontsRomanCO->addItem(font);
1696 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1697 QString font = qt_(tex_fonts_sans_gui[n]);
1698 if (!isFontAvailable(tex_fonts_sans[n]))
1699 font += qt_(" (not installed)");
1700 fontModule->fontsSansCO->addItem(font);
1702 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1703 QString font = qt_(tex_fonts_monospaced_gui[n]);
1704 if (!isFontAvailable(tex_fonts_monospaced[n]))
1705 font += qt_(" (not installed)");
1706 fontModule->fontsTypewriterCO->addItem(font);
1711 void GuiDocument::fontencChanged(int item)
1713 fontModule->fontencLE->setEnabled(item == 1);
1717 void GuiDocument::romanChanged(int item)
1719 if (fontModule->osFontsCB->isChecked())
1721 string const font = tex_fonts_roman[item];
1722 fontModule->fontScCB->setEnabled(providesSC(font));
1723 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1727 void GuiDocument::sansChanged(int item)
1729 if (fontModule->osFontsCB->isChecked())
1731 string const font = tex_fonts_sans[item];
1732 bool scaleable = providesScale(font);
1733 fontModule->scaleSansSB->setEnabled(scaleable);
1734 fontModule->scaleSansLA->setEnabled(scaleable);
1738 void GuiDocument::ttChanged(int item)
1740 if (fontModule->osFontsCB->isChecked())
1742 string const font = tex_fonts_monospaced[item];
1743 bool scaleable = providesScale(font);
1744 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1745 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1749 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1752 pageLayoutModule->pagestyleCO->clear();
1753 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1755 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1756 string style = token(items, '|', n);
1757 QString style_gui = qt_(style);
1758 pagestyles.push_back(pair<string, QString>(style, style_gui));
1759 pageLayoutModule->pagestyleCO->addItem(style_gui);
1762 if (sel == "default") {
1763 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1769 for (size_t i = 0; i < pagestyles.size(); ++i)
1770 if (pagestyles[i].first == sel)
1771 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1774 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1778 void GuiDocument::browseLayout()
1780 QString const label1 = qt_("Layouts|#o#O");
1781 QString const dir1 = toqstr(lyxrc.document_path);
1782 QStringList const filter(qt_("LyX Layout (*.layout)"));
1783 QString file = browseRelFile(QString(), bufferFilePath(),
1784 qt_("Local layout file"), filter, false,
1787 if (!file.endsWith(".layout"))
1790 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1791 fromqstr(bufferFilePath()));
1793 int const ret = Alert::prompt(_("Local layout file"),
1794 _("The layout file you have selected is a local layout\n"
1795 "file, not one in the system or user directory. Your\n"
1796 "document may not work with this layout if you do not\n"
1797 "keep the layout file in the document directory."),
1798 1, 1, _("&Set Layout"), _("&Cancel"));
1802 // load the layout file
1803 LayoutFileList & bcl = LayoutFileList::get();
1804 string classname = layoutFile.onlyFileName();
1805 // this will update an existing layout if that layout has been loaded before.
1806 LayoutFileIndex name = bcl.addLocalLayout(
1807 classname.substr(0, classname.size() - 7),
1808 layoutFile.onlyPath().absFileName());
1811 Alert::error(_("Error"),
1812 _("Unable to read local layout file."));
1816 // do not trigger classChanged if there is no change.
1817 if (latexModule->classCO->currentText() == toqstr(name))
1821 int idx = latexModule->classCO->findText(toqstr(name));
1823 classes_model_.insertRow(0, toqstr(name), name);
1824 latexModule->classCO->setCurrentIndex(0);
1826 latexModule->classCO->setCurrentIndex(idx);
1832 void GuiDocument::browseMaster()
1834 QString const title = qt_("Select master document");
1835 QString const dir1 = toqstr(lyxrc.document_path);
1836 QString const old = latexModule->childDocLE->text();
1837 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1838 QStringList const filter(qt_("LyX Files (*.lyx)"));
1839 QString file = browseRelFile(old, docpath, title, filter, false,
1840 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1842 if (!file.isEmpty())
1843 latexModule->childDocLE->setText(file);
1847 void GuiDocument::classChanged()
1849 int idx = latexModule->classCO->currentIndex();
1852 string const classname = classes_model_.getIDString(idx);
1854 // check whether the selected modules have changed.
1855 bool modules_changed = false;
1856 unsigned int const srows = selectedModel()->rowCount();
1857 if (srows != bp_.getModules().size())
1858 modules_changed = true;
1860 list<string>::const_iterator mit = bp_.getModules().begin();
1861 list<string>::const_iterator men = bp_.getModules().end();
1862 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1863 if (selectedModel()->getIDString(i) != *mit) {
1864 modules_changed = true;
1869 if (modules_changed || lyxrc.auto_reset_options) {
1870 if (applyPB->isEnabled()) {
1871 int const ret = Alert::prompt(_("Unapplied changes"),
1872 _("Some changes in the dialog were not yet applied.\n"
1873 "If you do not apply now, they will be lost after this action."),
1874 1, 1, _("&Apply"), _("&Dismiss"));
1880 // We load the TextClass as soon as it is selected. This is
1881 // necessary so that other options in the dialog can be updated
1882 // according to the new class. Note, however, that, if you use
1883 // the scroll wheel when sitting on the combo box, we'll load a
1884 // lot of TextClass objects very quickly....
1885 if (!bp_.setBaseClass(classname)) {
1886 Alert::error(_("Error"), _("Unable to set document class."));
1889 if (lyxrc.auto_reset_options)
1890 bp_.useClassDefaults();
1892 // With the introduction of modules came a distinction between the base
1893 // class and the document class. The former corresponds to the main layout
1894 // file; the latter is that plus the modules (or the document-specific layout,
1895 // or whatever else there could be). Our parameters come from the document
1896 // class. So when we set the base class, we also need to recreate the document
1897 // class. Otherwise, we still have the old one.
1898 bp_.makeDocumentClass();
1903 void GuiDocument::languagePackageChanged(int i)
1905 langModule->languagePackageED->setEnabled(
1906 langModule->languagePackageCO->itemData(i).toString() == "custom");
1910 void GuiDocument::bibtexChanged(int n)
1912 biblioModule->bibtexOptionsED->setEnabled(
1913 biblioModule->bibtexCO->itemData(n).toString() != "default");
1920 // both of these should take a vector<docstring>
1922 // This is an insanely complicated attempt to make this sort of thing
1923 // work with RTL languages.
1924 docstring formatStrVec(vector<string> const & v, docstring const & s)
1926 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1930 return translateIfPossible(from_utf8(v[0]));
1931 if (v.size() == 2) {
1932 docstring retval = _("%1$s and %2$s");
1933 retval = subst(retval, _("and"), s);
1934 return bformat(retval, translateIfPossible(from_utf8(v[0])),
1935 translateIfPossible(from_utf8(v[1])));
1937 // The idea here is to format all but the last two items...
1938 int const vSize = v.size();
1939 docstring t2 = _("%1$s, %2$s");
1940 docstring retval = translateIfPossible(from_utf8(v[0]));
1941 for (int i = 1; i < vSize - 2; ++i)
1942 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
1943 //...and then to plug them, and the last two, into this schema
1944 docstring t = _("%1$s, %2$s, and %3$s");
1945 t = subst(t, _("and"), s);
1946 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
1947 translateIfPossible(from_utf8(v[vSize - 1])));
1950 vector<string> idsToNames(vector<string> const & idList)
1952 vector<string> retval;
1953 vector<string>::const_iterator it = idList.begin();
1954 vector<string>::const_iterator end = idList.end();
1955 for (; it != end; ++it) {
1956 LyXModule const * const mod = theModuleList[*it];
1958 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
1959 translateIfPossible(from_utf8(*it)))));
1961 retval.push_back(mod->getName());
1965 } // end anonymous namespace
1968 void GuiDocument::modulesToParams(BufferParams & bp)
1970 // update list of loaded modules
1971 bp.clearLayoutModules();
1972 int const srows = modules_sel_model_.rowCount();
1973 for (int i = 0; i < srows; ++i)
1974 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1976 // update the list of removed modules
1977 bp.clearRemovedModules();
1978 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1979 list<string>::const_iterator rit = reqmods.begin();
1980 list<string>::const_iterator ren = reqmods.end();
1982 // check each of the default modules
1983 for (; rit != ren; rit++) {
1984 list<string>::const_iterator mit = bp.getModules().begin();
1985 list<string>::const_iterator men = bp.getModules().end();
1987 for (; mit != men; mit++) {
1994 // the module isn't present so must have been removed by the user
1995 bp.addRemovedModule(*rit);
2000 void GuiDocument::modulesChanged()
2002 modulesToParams(bp_);
2003 bp_.makeDocumentClass();
2008 void GuiDocument::updateModuleInfo()
2010 selectionManager->update();
2012 //Module description
2013 bool const focus_on_selected = selectionManager->selectedFocused();
2014 QAbstractItemView * lv;
2015 if (focus_on_selected)
2016 lv = modulesModule->selectedLV;
2018 lv= modulesModule->availableLV;
2019 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2020 modulesModule->infoML->document()->clear();
2023 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2024 GuiIdListModel const & id_model =
2025 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2026 string const modName = id_model.getIDString(idx.row());
2027 docstring desc = getModuleDescription(modName);
2029 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2030 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2033 desc += _("Module provided by document class.");
2036 vector<string> pkglist = getPackageList(modName);
2037 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2038 if (!pkgdesc.empty()) {
2041 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2044 pkglist = getRequiredList(modName);
2045 if (!pkglist.empty()) {
2046 vector<string> const reqdescs = idsToNames(pkglist);
2047 pkgdesc = formatStrVec(reqdescs, _("or"));
2050 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2053 pkglist = getExcludedList(modName);
2054 if (!pkglist.empty()) {
2055 vector<string> const reqdescs = idsToNames(pkglist);
2056 pkgdesc = formatStrVec(reqdescs, _( "and"));
2059 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2062 if (!isModuleAvailable(modName)) {
2065 desc += _("WARNING: Some required packages are unavailable!");
2068 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2072 void GuiDocument::updateNumbering()
2074 DocumentClass const & tclass = documentClass();
2076 numberingModule->tocTW->setUpdatesEnabled(false);
2077 numberingModule->tocTW->clear();
2079 int const depth = numberingModule->depthSL->value();
2080 int const toc = numberingModule->tocSL->value();
2081 QString const no = qt_("No");
2082 QString const yes = qt_("Yes");
2083 QTreeWidgetItem * item = 0;
2085 DocumentClass::const_iterator lit = tclass.begin();
2086 DocumentClass::const_iterator len = tclass.end();
2087 for (; lit != len; ++lit) {
2088 int const toclevel = lit->toclevel;
2089 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2090 item = new QTreeWidgetItem(numberingModule->tocTW);
2091 item->setText(0, toqstr(translateIfPossible(lit->name())));
2092 item->setText(1, (toclevel <= depth) ? yes : no);
2093 item->setText(2, (toclevel <= toc) ? yes : no);
2097 numberingModule->tocTW->setUpdatesEnabled(true);
2098 numberingModule->tocTW->update();
2102 void GuiDocument::updateDefaultFormat()
2106 // make a copy in order to consider unapplied changes
2107 Buffer * tmpbuf = buffer().clone();
2108 tmpbuf->params().useNonTeXFonts =
2109 fontModule->osFontsCB->isChecked();
2110 int idx = latexModule->classCO->currentIndex();
2112 string const classname = classes_model_.getIDString(idx);
2113 tmpbuf->params().setBaseClass(classname);
2114 tmpbuf->params().makeDocumentClass();
2116 outputModule->defaultFormatCO->blockSignals(true);
2117 outputModule->defaultFormatCO->clear();
2118 outputModule->defaultFormatCO->addItem(qt_("Default"),
2119 QVariant(QString("default")));
2120 typedef vector<Format const *> Formats;
2121 Formats formats = tmpbuf->exportableFormats(true);
2122 Formats::const_iterator cit = formats.begin();
2123 Formats::const_iterator end = formats.end();
2124 for (; cit != end; ++cit)
2125 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2126 QVariant(toqstr((*cit)->name())));
2127 outputModule->defaultFormatCO->blockSignals(false);
2133 bool GuiDocument::isChildIncluded(string const & child)
2135 if (includeonlys_.empty())
2137 return (std::find(includeonlys_.begin(),
2138 includeonlys_.end(), child) != includeonlys_.end());
2142 void GuiDocument::applyView()
2145 preambleModule->apply(bp_);
2146 localLayout->apply(bp_);
2149 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2150 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2153 bp_.setCiteEngine(ENGINE_BASIC);
2155 if (biblioModule->citeNatbibRB->isChecked()) {
2156 bool const use_numerical_citations =
2157 biblioModule->citeStyleCO->currentIndex();
2158 if (use_numerical_citations)
2159 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2161 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2163 } else if (biblioModule->citeJurabibRB->isChecked())
2164 bp_.setCiteEngine(ENGINE_JURABIB);
2167 biblioModule->bibtopicCB->isChecked();
2169 string const bibtex_command =
2170 fromqstr(biblioModule->bibtexCO->itemData(
2171 biblioModule->bibtexCO->currentIndex()).toString());
2172 string const bibtex_options =
2173 fromqstr(biblioModule->bibtexOptionsED->text());
2174 if (bibtex_command == "default" || bibtex_options.empty())
2175 bp_.bibtex_command = bibtex_command;
2177 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2180 indicesModule->apply(bp_);
2182 // language & quotes
2183 if (langModule->defaultencodingRB->isChecked()) {
2184 bp_.inputenc = "auto";
2186 int i = langModule->encodingCO->currentIndex();
2188 bp_.inputenc = "default";
2190 QString const enc_gui =
2191 langModule->encodingCO->currentText();
2192 Encodings::const_iterator it = encodings.begin();
2193 Encodings::const_iterator const end = encodings.end();
2195 for (; it != end; ++it) {
2196 if (qt_(it->guiName()) == enc_gui) {
2197 bp_.inputenc = it->latexName();
2203 // should not happen
2204 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2205 bp_.inputenc = "default";
2210 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2211 switch (langModule->quoteStyleCO->currentIndex()) {
2213 lga = InsetQuotes::EnglishQuotes;
2216 lga = InsetQuotes::SwedishQuotes;
2219 lga = InsetQuotes::GermanQuotes;
2222 lga = InsetQuotes::PolishQuotes;
2225 lga = InsetQuotes::FrenchQuotes;
2228 lga = InsetQuotes::DanishQuotes;
2231 bp_.quotes_language = lga;
2233 QString const lang = langModule->languageCO->itemData(
2234 langModule->languageCO->currentIndex()).toString();
2235 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2237 QString const pack = langModule->languagePackageCO->itemData(
2238 langModule->languagePackageCO->currentIndex()).toString();
2239 if (pack == "custom")
2241 fromqstr(langModule->languagePackageED->text());
2243 bp_.lang_package = fromqstr(pack);
2246 bp_.backgroundcolor = set_backgroundcolor;
2247 bp_.isbackgroundcolor = is_backgroundcolor;
2248 bp_.fontcolor = set_fontcolor;
2249 bp_.isfontcolor = is_fontcolor;
2250 bp_.notefontcolor = set_notefontcolor;
2251 bp_.boxbgcolor = set_boxbgcolor;
2254 if (bp_.documentClass().hasTocLevels()) {
2255 bp_.tocdepth = numberingModule->tocSL->value();
2256 bp_.secnumdepth = numberingModule->depthSL->value();
2260 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2261 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2262 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2263 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2266 bp_.graphics_driver =
2267 tex_graphics[latexModule->psdriverCO->currentIndex()];
2270 int idx = latexModule->classCO->currentIndex();
2272 string const classname = classes_model_.getIDString(idx);
2273 bp_.setBaseClass(classname);
2277 modulesToParams(bp_);
2280 if (mathsModule->amsautoCB->isChecked())
2281 bp_.use_amsmath = BufferParams::package_auto;
2283 if (mathsModule->amsCB->isChecked())
2284 bp_.use_amsmath = BufferParams::package_on;
2286 bp_.use_amsmath = BufferParams::package_off;
2288 if (mathsModule->esintautoCB->isChecked())
2289 bp_.use_esint = BufferParams::package_auto;
2291 if (mathsModule->esintCB->isChecked())
2292 bp_.use_esint = BufferParams::package_on;
2294 bp_.use_esint = BufferParams::package_off;
2296 if (mathsModule->mhchemautoCB->isChecked())
2297 bp_.use_mhchem = BufferParams::package_auto;
2299 if (mathsModule->mhchemCB->isChecked())
2300 bp_.use_mhchem = BufferParams::package_on;
2302 bp_.use_mhchem = BufferParams::package_off;
2304 if (mathsModule->mathdotsautoCB->isChecked())
2305 bp_.use_mathdots = BufferParams::package_auto;
2307 if (mathsModule->mathdotsCB->isChecked())
2308 bp_.use_mathdots = BufferParams::package_on;
2310 bp_.use_mathdots = BufferParams::package_off;
2314 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2315 bp_.pagestyle = "default";
2317 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2318 for (size_t i = 0; i != pagestyles.size(); ++i)
2319 if (pagestyles[i].second == style_gui)
2320 bp_.pagestyle = pagestyles[i].first;
2324 switch (textLayoutModule->lspacingCO->currentIndex()) {
2326 bp_.spacing().set(Spacing::Single);
2329 bp_.spacing().set(Spacing::Onehalf);
2332 bp_.spacing().set(Spacing::Double);
2335 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2337 bp_.spacing().set(Spacing::Single);
2339 bp_.spacing().set(Spacing::Other, s);
2344 if (textLayoutModule->twoColumnCB->isChecked())
2349 if (textLayoutModule->indentRB->isChecked()) {
2350 // if paragraphs are separated by an indentation
2351 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2352 switch (textLayoutModule->indentCO->currentIndex()) {
2354 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2357 HSpace indent = HSpace(
2358 widgetsToLength(textLayoutModule->indentLE,
2359 textLayoutModule->indentLengthCO)
2361 bp_.setIndentation(indent);
2365 // this should never happen
2366 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2370 // if paragraphs are separated by a skip
2371 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2372 switch (textLayoutModule->skipCO->currentIndex()) {
2374 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2377 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2380 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2385 widgetsToLength(textLayoutModule->skipLE,
2386 textLayoutModule->skipLengthCO)
2392 // this should never happen
2393 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2399 fromqstr(latexModule->optionsLE->text());
2401 bp_.use_default_options =
2402 latexModule->defaultOptionsCB->isChecked();
2404 if (latexModule->childDocGB->isChecked())
2406 fromqstr(latexModule->childDocLE->text());
2408 bp_.master = string();
2411 bp_.clearIncludedChildren();
2412 if (masterChildModule->includeonlyRB->isChecked()) {
2413 list<string>::const_iterator it = includeonlys_.begin();
2414 for (; it != includeonlys_.end() ; ++it) {
2415 bp_.addIncludedChildren(*it);
2418 bp_.maintain_unincluded_children =
2419 masterChildModule->maintainAuxCB->isChecked();
2422 bp_.float_placement = floatModule->get();
2425 // text should have passed validation
2426 bp_.listings_params =
2427 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2430 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2431 outputModule->defaultFormatCO->currentIndex()).toString());
2433 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2434 bp_.useNonTeXFonts = nontexfonts;
2436 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2437 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2439 int mathfmt = outputModule->mathoutCB->currentIndex();
2442 BufferParams::MathOutput const mo =
2443 static_cast<BufferParams::MathOutput>(mathfmt);
2444 bp_.html_math_output = mo;
2445 bp_.html_be_strict = outputModule->strictCB->isChecked();
2446 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2450 if (fontModule->fontsRomanCO->currentIndex() == 0)
2451 bp_.fonts_roman = "default";
2454 fromqstr(fontModule->fontsRomanCO->currentText());
2456 if (fontModule->fontsSansCO->currentIndex() == 0)
2457 bp_.fonts_sans = "default";
2460 fromqstr(fontModule->fontsSansCO->currentText());
2462 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
2463 bp_.fonts_typewriter = "default";
2465 bp_.fonts_typewriter =
2466 fromqstr(fontModule->fontsTypewriterCO->currentText());
2469 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
2472 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
2474 bp_.fonts_typewriter =
2475 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
2478 if (fontModule->fontencCO->currentIndex() == 0)
2479 bp_.fontenc = "global";
2480 else if (fontModule->fontencCO->currentIndex() == 1)
2481 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2482 else if (fontModule->fontencCO->currentIndex() == 2)
2483 bp_.fontenc = "default";
2486 fromqstr(fontModule->cjkFontLE->text());
2488 bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2490 bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2492 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2494 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2497 bp_.fonts_default_family = "default";
2499 bp_.fonts_default_family = GuiDocument::fontfamilies[
2500 fontModule->fontsDefaultCO->currentIndex()];
2502 if (fontModule->fontsizeCO->currentIndex() == 0)
2503 bp_.fontsize = "default";
2506 fromqstr(fontModule->fontsizeCO->currentText());
2509 bp_.papersize = PAPER_SIZE(
2510 pageLayoutModule->papersizeCO->currentIndex());
2512 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2513 pageLayoutModule->paperwidthUnitCO);
2515 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2516 pageLayoutModule->paperheightUnitCO);
2518 if (pageLayoutModule->facingPagesCB->isChecked())
2519 bp_.sides = TwoSides;
2521 bp_.sides = OneSide;
2523 if (pageLayoutModule->landscapeRB->isChecked())
2524 bp_.orientation = ORIENTATION_LANDSCAPE;
2526 bp_.orientation = ORIENTATION_PORTRAIT;
2529 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2531 Ui::MarginsUi const * m = marginsModule;
2533 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2534 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2535 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2536 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2537 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2538 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2539 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2540 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2543 branchesModule->apply(bp_);
2546 PDFOptions & pdf = bp_.pdfoptions();
2547 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2548 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2549 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2550 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2551 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2553 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2554 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2555 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2556 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2558 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2559 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2560 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2561 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2563 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2564 if (pdfSupportModule->fullscreenCB->isChecked())
2565 pdf.pagemode = pdf.pagemode_fullscreen;
2567 pdf.pagemode.clear();
2568 pdf.quoted_options = pdf.quoted_options_check(
2569 fromqstr(pdfSupportModule->optionsLE->text()));
2573 void GuiDocument::paramsToDialog()
2575 // set the default unit
2576 Length::UNIT const defaultUnit = Length::defaultUnit();
2579 preambleModule->update(bp_, id());
2580 localLayout->update(bp_, id());
2583 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2584 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2587 biblioModule->citeDefaultRB->setChecked(
2588 bp_.citeEngine() == ENGINE_BASIC);
2590 biblioModule->citeNatbibRB->setChecked(
2591 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2592 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2594 biblioModule->citeStyleCO->setCurrentIndex(
2595 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2597 biblioModule->citeJurabibRB->setChecked(
2598 bp_.citeEngine() == ENGINE_JURABIB);
2600 biblioModule->bibtopicCB->setChecked(
2605 split(bp_.bibtex_command, command, ' ');
2607 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2609 biblioModule->bibtexCO->setCurrentIndex(bpos);
2610 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2612 // We reset to default if we do not know the specified compiler
2613 // This is for security reasons
2614 biblioModule->bibtexCO->setCurrentIndex(
2615 biblioModule->bibtexCO->findData(toqstr("default")));
2616 biblioModule->bibtexOptionsED->clear();
2618 biblioModule->bibtexOptionsED->setEnabled(
2619 biblioModule->bibtexCO->currentIndex() != 0);
2622 indicesModule->update(bp_);
2624 // language & quotes
2625 int const pos = langModule->languageCO->findData(toqstr(
2626 bp_.language->lang()));
2627 langModule->languageCO->setCurrentIndex(pos);
2629 langModule->quoteStyleCO->setCurrentIndex(
2630 bp_.quotes_language);
2632 bool default_enc = true;
2633 if (bp_.inputenc != "auto") {
2634 default_enc = false;
2635 if (bp_.inputenc == "default") {
2636 langModule->encodingCO->setCurrentIndex(0);
2639 Encodings::const_iterator it = encodings.begin();
2640 Encodings::const_iterator const end = encodings.end();
2641 for (; it != end; ++it) {
2642 if (it->latexName() == bp_.inputenc) {
2643 enc_gui = it->guiName();
2647 int const i = langModule->encodingCO->findText(
2650 langModule->encodingCO->setCurrentIndex(i);
2652 // unknown encoding. Set to default.
2656 langModule->defaultencodingRB->setChecked(default_enc);
2657 langModule->otherencodingRB->setChecked(!default_enc);
2659 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2661 langModule->languagePackageCO->setCurrentIndex(
2662 langModule->languagePackageCO->findData("custom"));
2663 langModule->languagePackageED->setText(toqstr(bp_.lang_package));
2665 langModule->languagePackageCO->setCurrentIndex(p);
2666 langModule->languagePackageED->clear();
2670 if (bp_.isfontcolor) {
2671 colorModule->fontColorPB->setStyleSheet(
2672 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2674 set_fontcolor = bp_.fontcolor;
2675 is_fontcolor = bp_.isfontcolor;
2677 colorModule->noteFontColorPB->setStyleSheet(
2678 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2679 set_notefontcolor = bp_.notefontcolor;
2681 if (bp_.isbackgroundcolor) {
2682 colorModule->backgroundPB->setStyleSheet(
2683 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2685 set_backgroundcolor = bp_.backgroundcolor;
2686 is_backgroundcolor = bp_.isbackgroundcolor;
2688 colorModule->boxBackgroundPB->setStyleSheet(
2689 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2690 set_boxbgcolor = bp_.boxbgcolor;
2693 int const min_toclevel = documentClass().min_toclevel();
2694 int const max_toclevel = documentClass().max_toclevel();
2695 if (documentClass().hasTocLevels()) {
2696 numberingModule->setEnabled(true);
2697 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2698 numberingModule->depthSL->setMaximum(max_toclevel);
2699 numberingModule->depthSL->setValue(bp_.secnumdepth);
2700 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2701 numberingModule->tocSL->setMaximum(max_toclevel);
2702 numberingModule->tocSL->setValue(bp_.tocdepth);
2705 numberingModule->setEnabled(false);
2706 numberingModule->tocTW->clear();
2710 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2711 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2712 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2713 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2714 bulletsModule->init();
2717 int nitem = findToken(tex_graphics, bp_.graphics_driver);
2719 latexModule->psdriverCO->setCurrentIndex(nitem);
2722 mathsModule->amsCB->setChecked(
2723 bp_.use_amsmath == BufferParams::package_on);
2724 mathsModule->amsautoCB->setChecked(
2725 bp_.use_amsmath == BufferParams::package_auto);
2727 mathsModule->esintCB->setChecked(
2728 bp_.use_esint == BufferParams::package_on);
2729 mathsModule->esintautoCB->setChecked(
2730 bp_.use_esint == BufferParams::package_auto);
2732 mathsModule->mhchemCB->setChecked(
2733 bp_.use_mhchem == BufferParams::package_on);
2734 mathsModule->mhchemautoCB->setChecked(
2735 bp_.use_mhchem == BufferParams::package_auto);
2737 mathsModule->mathdotsCB->setChecked(
2738 bp_.use_mathdots == BufferParams::package_on);
2739 mathsModule->mathdotsautoCB->setChecked(
2740 bp_.use_mathdots == BufferParams::package_auto);
2742 switch (bp_.spacing().getSpace()) {
2743 case Spacing::Other: nitem = 3; break;
2744 case Spacing::Double: nitem = 2; break;
2745 case Spacing::Onehalf: nitem = 1; break;
2746 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2750 string const & layoutID = bp_.baseClassID();
2751 setLayoutComboByIDString(layoutID);
2753 updatePagestyle(documentClass().opt_pagestyle(),
2756 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2757 if (bp_.spacing().getSpace() == Spacing::Other) {
2758 doubleToWidget(textLayoutModule->lspacingLE,
2759 bp_.spacing().getValueAsString());
2763 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2764 textLayoutModule->indentRB->setChecked(true);
2765 string indentation = bp_.getIndentation().asLyXCommand();
2767 if (indentation != "default") {
2768 lengthToWidgets(textLayoutModule->indentLE,
2769 textLayoutModule->indentLengthCO,
2770 indentation, defaultUnit);
2773 textLayoutModule->indentCO->setCurrentIndex(indent);
2776 textLayoutModule->skipRB->setChecked(true);
2778 switch (bp_.getDefSkip().kind()) {
2779 case VSpace::SMALLSKIP:
2782 case VSpace::MEDSKIP:
2785 case VSpace::BIGSKIP:
2788 case VSpace::LENGTH:
2791 string const length = bp_.getDefSkip().asLyXCommand();
2792 lengthToWidgets(textLayoutModule->skipLE,
2793 textLayoutModule->skipLengthCO,
2794 length, defaultUnit);
2801 textLayoutModule->skipCO->setCurrentIndex(skip);
2805 textLayoutModule->twoColumnCB->setChecked(
2808 if (!bp_.options.empty()) {
2809 latexModule->optionsLE->setText(
2810 toqstr(bp_.options));
2812 latexModule->optionsLE->setText(QString());
2816 latexModule->defaultOptionsCB->setChecked(
2817 bp_.use_default_options);
2818 updateSelectedModules();
2819 selectionManager->updateProvidedModules(
2820 bp_.baseClass()->providedModules());
2821 selectionManager->updateExcludedModules(
2822 bp_.baseClass()->excludedModules());
2824 if (!documentClass().options().empty()) {
2825 latexModule->defaultOptionsLE->setText(
2826 toqstr(documentClass().options()));
2828 latexModule->defaultOptionsLE->setText(
2829 toqstr(_("[No options predefined]")));
2832 latexModule->defaultOptionsLE->setEnabled(
2833 bp_.use_default_options
2834 && !documentClass().options().empty());
2836 latexModule->defaultOptionsCB->setEnabled(
2837 !documentClass().options().empty());
2839 if (!bp_.master.empty()) {
2840 latexModule->childDocGB->setChecked(true);
2841 latexModule->childDocLE->setText(
2842 toqstr(bp_.master));
2844 latexModule->childDocLE->setText(QString());
2845 latexModule->childDocGB->setChecked(false);
2849 if (!bufferview() || !buffer().hasChildren()) {
2850 masterChildModule->childrenTW->clear();
2851 includeonlys_.clear();
2852 docPS->showPanel(qt_("Child Documents"), false);
2853 if (docPS->isCurrentPanel(qt_("Child Documents")))
2854 docPS->setCurrentPanel(qt_("Document Class"));
2856 docPS->showPanel(qt_("Child Documents"), true);
2857 masterChildModule->setEnabled(true);
2858 includeonlys_ = bp_.getIncludedChildren();
2859 updateIncludeonlys();
2861 masterChildModule->maintainAuxCB->setChecked(
2862 bp_.maintain_unincluded_children);
2865 floatModule->set(bp_.float_placement);
2868 // break listings_params to multiple lines
2870 InsetListingsParams(bp_.listings_params).separatedParams();
2871 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2874 // update combobox with formats
2875 updateDefaultFormat();
2876 int index = outputModule->defaultFormatCO->findData(toqstr(
2877 bp_.default_output_format));
2878 // set to default if format is not found
2881 outputModule->defaultFormatCO->setCurrentIndex(index);
2882 bool const os_fonts_available =
2883 bp_.baseClass()->outputType() == lyx::LATEX
2884 && LaTeXFeatures::isAvailable("fontspec");
2885 fontModule->osFontsCB->setEnabled(os_fonts_available);
2886 fontModule->osFontsCB->setChecked(
2887 os_fonts_available && bp_.useNonTeXFonts);
2889 outputModule->outputsyncCB->setChecked(bp_.output_sync);
2890 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2892 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2893 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2894 outputModule->strictCB->setChecked(bp_.html_be_strict);
2897 updateFontsize(documentClass().opt_fontsize(),
2900 if (bp_.useNonTeXFonts && os_fonts_available) {
2901 fontModule->fontencLA->setEnabled(false);
2902 fontModule->fontencCO->setEnabled(false);
2903 fontModule->fontencLE->setEnabled(false);
2904 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2905 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fonts_roman)) {
2906 fontModule->fontsRomanCO->setCurrentIndex(i);
2911 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2912 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fonts_sans)) {
2913 fontModule->fontsSansCO->setCurrentIndex(i);
2917 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2918 if (fontModule->fontsTypewriterCO->itemText(i) ==
2919 toqstr(bp_.fonts_typewriter)) {
2920 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2925 fontModule->fontencLA->setEnabled(true);
2926 fontModule->fontencCO->setEnabled(true);
2927 fontModule->fontencLE->setEnabled(true);
2928 int n = findToken(tex_fonts_roman, bp_.fonts_roman);
2930 fontModule->fontsRomanCO->setCurrentIndex(n);
2934 n = findToken(tex_fonts_sans, bp_.fonts_sans);
2936 fontModule->fontsSansCO->setCurrentIndex(n);
2940 n = findToken(tex_fonts_monospaced, bp_.fonts_typewriter);
2942 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2947 if (!bp_.fonts_cjk.empty())
2948 fontModule->cjkFontLE->setText(
2949 toqstr(bp_.fonts_cjk));
2951 fontModule->cjkFontLE->setText(QString());
2953 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
2954 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
2955 fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
2956 fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
2958 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
2960 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2962 if (bp_.fontenc == "global") {
2963 fontModule->fontencCO->setCurrentIndex(0);
2964 fontModule->fontencLE->setEnabled(false);
2965 } else if (bp_.fontenc == "default") {
2966 fontModule->fontencCO->setCurrentIndex(2);
2967 fontModule->fontencLE->setEnabled(false);
2969 fontModule->fontencCO->setCurrentIndex(1);
2970 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2974 bool const extern_geometry =
2975 documentClass().provides("geometry");
2976 int const psize = bp_.papersize;
2977 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2978 setCustomPapersize(!extern_geometry && psize == 1);
2979 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2981 bool const landscape =
2982 bp_.orientation == ORIENTATION_LANDSCAPE;
2983 pageLayoutModule->landscapeRB->setChecked(landscape);
2984 pageLayoutModule->portraitRB->setChecked(!landscape);
2985 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2986 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2988 pageLayoutModule->facingPagesCB->setChecked(
2989 bp_.sides == TwoSides);
2991 lengthToWidgets(pageLayoutModule->paperwidthLE,
2992 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2993 lengthToWidgets(pageLayoutModule->paperheightLE,
2994 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2997 Ui::MarginsUi * m = marginsModule;
3001 lengthToWidgets(m->topLE, m->topUnit,
3002 bp_.topmargin, defaultUnit);
3004 lengthToWidgets(m->bottomLE, m->bottomUnit,
3005 bp_.bottommargin, defaultUnit);
3007 lengthToWidgets(m->innerLE, m->innerUnit,
3008 bp_.leftmargin, defaultUnit);
3010 lengthToWidgets(m->outerLE, m->outerUnit,
3011 bp_.rightmargin, defaultUnit);
3013 lengthToWidgets(m->headheightLE, m->headheightUnit,
3014 bp_.headheight, defaultUnit);
3016 lengthToWidgets(m->headsepLE, m->headsepUnit,
3017 bp_.headsep, defaultUnit);
3019 lengthToWidgets(m->footskipLE, m->footskipUnit,
3020 bp_.footskip, defaultUnit);
3022 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3023 bp_.columnsep, defaultUnit);
3026 updateUnknownBranches();
3027 branchesModule->update(bp_);
3030 PDFOptions const & pdf = bp_.pdfoptions();
3031 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3032 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3033 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3034 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3035 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3037 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3038 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3039 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3041 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3043 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3044 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3045 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3046 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3048 nn = findToken(backref_opts, pdf.backref);
3050 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3052 pdfSupportModule->fullscreenCB->setChecked
3053 (pdf.pagemode == pdf.pagemode_fullscreen);
3055 pdfSupportModule->optionsLE->setText(
3056 toqstr(pdf.quoted_options));
3058 // Make sure that the bc is in the INITIAL state
3059 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3062 // clear changed branches cache
3063 changedBranches_.clear();
3067 void GuiDocument::saveDocDefault()
3069 // we have to apply the params first
3075 void GuiDocument::updateAvailableModules()
3077 modules_av_model_.clear();
3078 list<modInfoStruct> const & modInfoList = getModuleInfo();
3079 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3080 list<modInfoStruct>::const_iterator men = modInfoList.end();
3081 for (int i = 0; mit != men; ++mit, ++i)
3082 modules_av_model_.insertRow(i, mit->name, mit->id,
3087 void GuiDocument::updateSelectedModules()
3089 modules_sel_model_.clear();
3090 list<modInfoStruct> const selModList = getSelectedModules();
3091 list<modInfoStruct>::const_iterator mit = selModList.begin();
3092 list<modInfoStruct>::const_iterator men = selModList.end();
3093 for (int i = 0; mit != men; ++mit, ++i)
3094 modules_sel_model_.insertRow(i, mit->name, mit->id,
3099 void GuiDocument::updateIncludeonlys()
3101 masterChildModule->childrenTW->clear();
3102 QString const no = qt_("No");
3103 QString const yes = qt_("Yes");
3105 if (includeonlys_.empty()) {
3106 masterChildModule->includeallRB->setChecked(true);
3107 masterChildModule->childrenTW->setEnabled(false);
3108 masterChildModule->maintainAuxCB->setEnabled(false);
3110 masterChildModule->includeonlyRB->setChecked(true);
3111 masterChildModule->childrenTW->setEnabled(true);
3112 masterChildModule->maintainAuxCB->setEnabled(true);
3114 QTreeWidgetItem * item = 0;
3115 ListOfBuffers children = buffer().getChildren();
3116 ListOfBuffers::const_iterator it = children.begin();
3117 ListOfBuffers::const_iterator end = children.end();
3118 bool has_unincluded = false;
3119 bool all_unincluded = true;
3120 for (; it != end; ++it) {
3121 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3124 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3125 from_utf8(buffer().filePath())));
3126 item->setText(0, toqstr(name));
3127 item->setText(1, isChildIncluded(name) ? yes : no);
3128 if (!isChildIncluded(name))
3129 has_unincluded = true;
3131 all_unincluded = false;
3133 // Both if all childs are included and if none is included
3134 // is equal to "include all" (i.e., ommit \includeonly).
3135 // Thus, reset the GUI.
3136 if (!has_unincluded || all_unincluded) {
3137 masterChildModule->includeallRB->setChecked(true);
3138 masterChildModule->childrenTW->setEnabled(false);
3139 includeonlys_.clear();
3141 // If all are included, we need to update again.
3142 if (!has_unincluded)
3143 updateIncludeonlys();
3147 void GuiDocument::updateContents()
3149 // Nothing to do here as the document settings is not cursor dependant.
3154 void GuiDocument::useClassDefaults()
3156 if (applyPB->isEnabled()) {
3157 int const ret = Alert::prompt(_("Unapplied changes"),
3158 _("Some changes in the dialog were not yet applied.\n"
3159 "If you do not apply now, they will be lost after this action."),
3160 1, 1, _("&Apply"), _("&Dismiss"));
3165 int idx = latexModule->classCO->currentIndex();
3166 string const classname = classes_model_.getIDString(idx);
3167 if (!bp_.setBaseClass(classname)) {
3168 Alert::error(_("Error"), _("Unable to set document class."));
3171 bp_.useClassDefaults();
3176 void GuiDocument::setLayoutComboByIDString(string const & idString)
3178 int idx = classes_model_.findIDString(idString);
3180 Alert::warning(_("Can't set layout!"),
3181 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3183 latexModule->classCO->setCurrentIndex(idx);
3187 bool GuiDocument::isValid()
3190 validateListingsParameters().isEmpty() &&
3191 localLayout->isValid() &&
3193 // if we're asking for skips between paragraphs
3194 !textLayoutModule->skipRB->isChecked() ||
3195 // then either we haven't chosen custom
3196 textLayoutModule->skipCO->currentIndex() != 3 ||
3197 // or else a length has been given
3198 !textLayoutModule->skipLE->text().isEmpty()
3201 // if we're asking for indentation
3202 !textLayoutModule->indentRB->isChecked() ||
3203 // then either we haven't chosen custom
3204 textLayoutModule->indentCO->currentIndex() != 1 ||
3205 // or else a length has been given
3206 !textLayoutModule->indentLE->text().isEmpty()
3211 char const * const GuiDocument::fontfamilies[5] = {
3212 "default", "rmdefault", "sfdefault", "ttdefault", ""
3216 char const * GuiDocument::fontfamilies_gui[5] = {
3217 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3221 bool GuiDocument::initialiseParams(string const &)
3223 BufferView const * view = bufferview();
3225 bp_ = BufferParams();
3229 bp_ = view->buffer().params();
3231 updateAvailableModules();
3232 //FIXME It'd be nice to make sure here that the selected
3233 //modules are consistent: That required modules are actually
3234 //selected, and that we don't have conflicts. If so, we could
3235 //at least pop up a warning.
3241 void GuiDocument::clearParams()
3243 bp_ = BufferParams();
3247 BufferId GuiDocument::id() const
3249 BufferView const * const view = bufferview();
3250 return view? &view->buffer() : 0;
3254 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3256 return moduleNames_;
3260 list<GuiDocument::modInfoStruct> const
3261 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3263 LayoutModuleList::const_iterator it = mods.begin();
3264 LayoutModuleList::const_iterator end = mods.end();
3265 list<modInfoStruct> mInfo;
3266 for (; it != end; ++it) {
3269 LyXModule const * const mod = theModuleList[*it];
3272 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3274 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3281 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3283 return makeModuleInfo(params().getModules());
3287 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3289 return makeModuleInfo(params().baseClass()->providedModules());
3293 DocumentClass const & GuiDocument::documentClass() const
3295 return bp_.documentClass();
3299 static void dispatch_bufferparams(Dialog const & dialog,
3300 BufferParams const & bp, FuncCode lfun)
3303 ss << "\\begin_header\n";
3305 ss << "\\end_header\n";
3306 dialog.dispatch(FuncRequest(lfun, ss.str()));
3310 void GuiDocument::dispatchParams()
3312 // This must come first so that a language change is correctly noticed
3315 // Apply the BufferParams. Note that this will set the base class
3316 // and then update the buffer's layout.
3317 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3319 if (!params().master.empty()) {
3320 FileName const master_file = support::makeAbsPath(params().master,
3321 support::onlyPath(buffer().absFileName()));
3322 if (isLyXFileName(master_file.absFileName())) {
3323 Buffer * master = checkAndLoadLyXFile(master_file);
3325 if (master->isChild(const_cast<Buffer *>(&buffer())))
3326 const_cast<Buffer &>(buffer()).setParent(master);
3328 Alert::warning(_("Assigned master does not include this file"),
3329 bformat(_("You must include this file in the document\n"
3330 "'%1$s' in order to use the master document\n"
3331 "feature."), from_utf8(params().master)));
3333 Alert::warning(_("Could not load master"),
3334 bformat(_("The master document '%1$s'\n"
3335 "could not be loaded."),
3336 from_utf8(params().master)));
3340 // Generate the colours requested by each new branch.
3341 BranchList & branchlist = params().branchlist();
3342 if (!branchlist.empty()) {
3343 BranchList::const_iterator it = branchlist.begin();
3344 BranchList::const_iterator const end = branchlist.end();
3345 for (; it != end; ++it) {
3346 docstring const & current_branch = it->branch();
3347 Branch const * branch = branchlist.find(current_branch);
3348 string const x11hexname = X11hexname(branch->color());
3349 // display the new color
3350 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3351 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3354 // Open insets of selected branches, close deselected ones
3355 dispatch(FuncRequest(LFUN_INSET_FORALL,
3356 "Branch inset-toggle assign"));
3358 // rename branches in the document
3359 executeBranchRenaming();
3360 // and clear changed branches cache
3361 changedBranches_.clear();
3363 // Generate the colours requested by indices.
3364 IndicesList & indiceslist = params().indiceslist();
3365 if (!indiceslist.empty()) {
3366 IndicesList::const_iterator it = indiceslist.begin();
3367 IndicesList::const_iterator const end = indiceslist.end();
3368 for (; it != end; ++it) {
3369 docstring const & current_index = it->shortcut();
3370 Index const * index = indiceslist.findShortcut(current_index);
3371 string const x11hexname = X11hexname(index->color());
3372 // display the new color
3373 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3374 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3378 // If we used an LFUN, we would not need these two lines:
3379 BufferView * bv = const_cast<BufferView *>(bufferview());
3380 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3384 void GuiDocument::setLanguage() const
3386 Language const * const newL = bp_.language;
3387 if (buffer().params().language == newL)
3390 string const & lang_name = newL->lang();
3391 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3395 void GuiDocument::saveAsDefault() const
3397 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3401 bool GuiDocument::isFontAvailable(string const & font) const
3403 if (font == "default" || font == "cmr"
3404 || font == "cmss" || font == "cmtt")
3405 // these are standard
3407 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3408 return LaTeXFeatures::isAvailable("lmodern");
3409 if (font == "times" || font == "palatino"
3410 || font == "helvet" || font == "courier")
3411 return LaTeXFeatures::isAvailable("psnfss");
3412 if (font == "cmbr" || font == "cmtl")
3413 return LaTeXFeatures::isAvailable("cmbright");
3414 if (font == "utopia")
3415 return LaTeXFeatures::isAvailable("utopia")
3416 || LaTeXFeatures::isAvailable("fourier");
3417 if (font == "beraserif" || font == "berasans"
3418 || font == "beramono")
3419 return LaTeXFeatures::isAvailable("bera");
3420 return LaTeXFeatures::isAvailable(font);
3424 bool GuiDocument::providesOSF(string const & font) const
3426 if (fontModule->osFontsCB->isChecked())
3427 // FIXME: we should check if the fonts really
3428 // have OSF support. But how?
3431 return isFontAvailable("eco");
3432 if (font == "palatino")
3433 return isFontAvailable("mathpazo");
3438 bool GuiDocument::providesSC(string const & font) const
3440 if (fontModule->osFontsCB->isChecked())
3442 if (font == "palatino")
3443 return isFontAvailable("mathpazo");
3444 if (font == "utopia")
3445 return isFontAvailable("fourier");
3450 bool GuiDocument::providesScale(string const & font) const
3452 if (fontModule->osFontsCB->isChecked())
3454 return font == "helvet" || font == "luximono"
3455 || font == "berasans" || font == "beramono";
3459 void GuiDocument::loadModuleInfo()
3461 moduleNames_.clear();
3462 LyXModuleList::const_iterator it = theModuleList.begin();
3463 LyXModuleList::const_iterator end = theModuleList.end();
3464 for (; it != end; ++it) {
3468 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3469 // this is supposed to give us the first sentence of the description
3472 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3473 int const pos = desc.indexOf(".");
3475 desc.truncate(pos + 1);
3476 m.description = desc;
3477 moduleNames_.push_back(m);
3482 void GuiDocument::updateUnknownBranches()
3486 list<docstring> used_branches;
3487 buffer().getUsedBranches(used_branches);
3488 list<docstring>::const_iterator it = used_branches.begin();
3489 QStringList unknown_branches;
3490 for (; it != used_branches.end() ; ++it) {
3491 if (!buffer().params().branchlist().find(*it))
3492 unknown_branches.append(toqstr(*it));
3494 branchesModule->setUnknownBranches(unknown_branches);
3498 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3500 map<docstring, docstring>::iterator it = changedBranches_.begin();
3501 for (; it != changedBranches_.end() ; ++it) {
3502 if (it->second == oldname) {
3503 // branch has already been renamed
3504 it->second = newname;
3509 changedBranches_[oldname] = newname;
3513 void GuiDocument::executeBranchRenaming() const
3515 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3516 for (; it != changedBranches_.end() ; ++it) {
3517 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3518 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3523 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3526 } // namespace frontend
3529 #include "moc_GuiDocument.cpp"