2 * \file GuiDocument.cpp
3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
7 * \author Richard Heck (modules)
9 * Full author contact details are available in file CREDITS.
14 #include "GuiDocument.h"
16 #include "GuiApplication.h"
17 #include "GuiBranches.h"
18 #include "GuiIndices.h"
19 #include "GuiSelectionManager.h"
20 #include "LaTeXHighlighter.h"
21 #include "LengthCombo.h"
22 #include "PanelStack.h"
23 #include "Validator.h"
25 #include "LayoutFile.h"
26 #include "BranchList.h"
27 #include "buffer_funcs.h"
29 #include "BufferParams.h"
30 #include "BufferView.h"
32 #include "ColorCache.h"
34 #include "FloatPlacement.h"
36 #include "FuncRequest.h"
38 #include "IndicesList.h"
40 #include "LaTeXFeatures.h"
42 #include "LayoutModuleList.h"
44 #include "ModuleList.h"
45 #include "OutputParams.h"
46 #include "PDFOptions.h"
47 #include "qt_helpers.h"
49 #include "TextClass.h"
51 #include "insets/InsetListingsParams.h"
53 #include "support/debug.h"
54 #include "support/FileName.h"
55 #include "support/filetools.h"
56 #include "support/gettext.h"
57 #include "support/lstrings.h"
59 #include "frontends/alert.h"
61 #include <QAbstractItemModel>
62 #include <QHeaderView>
64 #include <QColorDialog>
65 #include <QCloseEvent>
66 #include <QFontDatabase>
68 #include <QTextCursor>
78 // a style sheet for buttons
79 // this is for example used for the background color setting button
80 static inline QString colorButtonStyleSheet(QColor const & bgColor)
82 if (bgColor.isValid()) {
83 QString rc = QLatin1String("background-color:");
92 using namespace lyx::support;
97 char const * const tex_graphics[] =
99 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
100 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
101 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
102 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
107 char const * const tex_graphics_gui[] =
109 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
110 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
111 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
112 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
113 "XeTeX", N_("None"), ""
117 char const * const tex_fonts_roman[] =
119 "default", "cmr", "lmodern", "ae", "times", "palatino",
120 "charter", "newcent", "bookman", "utopia", "beraserif",
121 "ccfonts", "chancery", ""
125 char const * tex_fonts_roman_gui[] =
127 N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
128 N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
129 N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
130 N_("Utopia"), N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
135 char const * const tex_fonts_sans[] =
137 "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
141 char const * tex_fonts_sans_gui[] =
143 N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
144 N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
148 char const * const tex_fonts_monospaced[] =
150 "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
154 char const * tex_fonts_monospaced_gui[] =
156 N_("Default"), N_("Computer Modern Typewriter"),
157 N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
158 N_("LuxiMono"), N_("CM Typewriter Light"), ""
162 char const * backref_opts[] =
164 "false", "section", "slide", "page", ""
168 char const * backref_opts_gui[] =
170 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
174 vector<pair<string, QString> > pagestyles;
177 } // anonymous namespace
181 RGBColor set_backgroundcolor;
182 bool is_backgroundcolor;
183 RGBColor set_fontcolor;
185 RGBColor set_notefontcolor;
186 RGBColor set_boxbgcolor;
189 // used when sorting the textclass list.
190 class less_textclass_avail_desc
191 : public binary_function<string, string, int>
194 bool operator()(string const & lhs, string const & rhs) const
196 // Ordering criteria:
197 // 1. Availability of text class
198 // 2. Description (lexicographic)
199 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
200 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
201 int const order = compare_no_case(
202 translateIfPossible(from_utf8(tc1.description())),
203 translateIfPossible(from_utf8(tc2.description())));
204 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
205 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
214 vector<string> getRequiredList(string const & modName)
216 LyXModule const * const mod = theModuleList[modName];
218 return vector<string>(); //empty such thing
219 return mod->getRequiredModules();
223 vector<string> getExcludedList(string const & modName)
225 LyXModule const * const mod = theModuleList[modName];
227 return vector<string>(); //empty such thing
228 return mod->getExcludedModules();
232 docstring getModuleDescription(string const & modName)
234 LyXModule const * const mod = theModuleList[modName];
236 return _("Module not found!");
238 return translateIfPossible(from_utf8(mod->getDescription()));
242 vector<string> getPackageList(string const & modName)
244 LyXModule const * const mod = theModuleList[modName];
246 return vector<string>(); //empty such thing
247 return mod->getPackageList();
251 bool isModuleAvailable(string const & modName)
253 LyXModule const * const mod = theModuleList[modName];
256 return mod->isAvailable();
259 } // anonymous namespace
262 /////////////////////////////////////////////////////////////////////
264 // ModuleSelectionManager
266 /////////////////////////////////////////////////////////////////////
268 /// SelectionManager for use with modules
269 class ModuleSelectionManager : public GuiSelectionManager
273 ModuleSelectionManager(
274 QTreeView * availableLV,
275 QListView * selectedLV,
279 QPushButton * downPB,
280 GuiIdListModel * availableModel,
281 GuiIdListModel * selectedModel,
282 GuiDocument const * container)
283 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
284 upPB, downPB, availableModel, selectedModel), container_(container)
287 void updateProvidedModules(LayoutModuleList const & pm)
288 { provided_modules_ = pm.list(); }
290 void updateExcludedModules(LayoutModuleList const & em)
291 { excluded_modules_ = em.list(); }
294 virtual void updateAddPB();
296 virtual void updateUpPB();
298 virtual void updateDownPB();
300 virtual void updateDelPB();
301 /// returns availableModel as a GuiIdListModel
302 GuiIdListModel * getAvailableModel()
304 return dynamic_cast<GuiIdListModel *>(availableModel);
306 /// returns selectedModel as a GuiIdListModel
307 GuiIdListModel * getSelectedModel()
309 return dynamic_cast<GuiIdListModel *>(selectedModel);
311 /// keeps a list of the modules the text class provides
312 list<string> provided_modules_;
314 list<string> excluded_modules_;
316 GuiDocument const * container_;
319 void ModuleSelectionManager::updateAddPB()
321 int const arows = availableModel->rowCount();
322 QModelIndexList const avail_sels =
323 availableLV->selectionModel()->selectedIndexes();
325 // disable if there aren't any modules (?), if none of them is chosen
326 // in the dialog, or if the chosen one is already selected for use.
327 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
328 addPB->setEnabled(false);
332 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
333 string const modname = getAvailableModel()->getIDString(idx.row());
336 container_->params().moduleCanBeAdded(modname);
337 addPB->setEnabled(enable);
341 void ModuleSelectionManager::updateDownPB()
343 int const srows = selectedModel->rowCount();
345 downPB->setEnabled(false);
348 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
349 int const curRow = curidx.row();
350 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
351 downPB->setEnabled(false);
355 // determine whether immediately succeding element requires this one
356 string const curmodname = getSelectedModel()->getIDString(curRow);
357 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
359 vector<string> reqs = getRequiredList(nextmodname);
361 // if it doesn't require anything....
363 downPB->setEnabled(true);
367 // Enable it if this module isn't required.
368 // FIXME This should perhaps be more flexible and check whether, even
369 // if the next one is required, there is also an earlier one that will do.
371 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
374 void ModuleSelectionManager::updateUpPB()
376 int const srows = selectedModel->rowCount();
378 upPB->setEnabled(false);
382 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
383 int curRow = curIdx.row();
384 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
385 upPB->setEnabled(false);
388 string const curmodname = getSelectedModel()->getIDString(curRow);
390 // determine whether immediately preceding element is required by this one
391 vector<string> reqs = getRequiredList(curmodname);
393 // if this one doesn't require anything....
395 upPB->setEnabled(true);
400 // Enable it if the preceding module isn't required.
401 // NOTE This is less flexible than it might be. We could check whether, even
402 // if the previous one is required, there is an earlier one that would do.
403 string const premod = getSelectedModel()->getIDString(curRow - 1);
404 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
407 void ModuleSelectionManager::updateDelPB()
409 int const srows = selectedModel->rowCount();
411 deletePB->setEnabled(false);
415 QModelIndex const & curidx =
416 selectedLV->selectionModel()->currentIndex();
417 int const curRow = curidx.row();
418 if (curRow < 0 || curRow >= srows) { // invalid index?
419 deletePB->setEnabled(false);
423 string const curmodname = getSelectedModel()->getIDString(curRow);
425 // We're looking here for a reason NOT to enable the button. If we
426 // find one, we disable it and return. If we don't, we'll end up at
427 // the end of the function, and then we enable it.
428 for (int i = curRow + 1; i < srows; ++i) {
429 string const thisMod = getSelectedModel()->getIDString(i);
430 vector<string> reqs = getRequiredList(thisMod);
431 //does this one require us?
432 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
436 // OK, so this module requires us
437 // is there an EARLIER module that also satisfies the require?
438 // NOTE We demand that it be earlier to keep the list of modules
439 // consistent with the rule that a module must be proceeded by a
440 // required module. There would be more flexible ways to proceed,
441 // but that would be a lot more complicated, and the logic here is
442 // already complicated. (That's why I've left the debugging code.)
443 // lyxerr << "Testing " << thisMod << endl;
444 bool foundone = false;
445 for (int j = 0; j < curRow; ++j) {
446 string const mod = getSelectedModel()->getIDString(j);
447 // lyxerr << "In loop: Testing " << mod << endl;
448 // do we satisfy the require?
449 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
450 // lyxerr << mod << " does the trick." << endl;
455 // did we find a module to satisfy the require?
457 // lyxerr << "No matching module found." << endl;
458 deletePB->setEnabled(false);
462 // lyxerr << "All's well that ends well." << endl;
463 deletePB->setEnabled(true);
467 /////////////////////////////////////////////////////////////////////
471 /////////////////////////////////////////////////////////////////////
473 PreambleModule::PreambleModule() : current_id_(0)
475 // This is not a memory leak. The object will be destroyed
477 (void) new LaTeXHighlighter(preambleTE->document());
478 setFocusProxy(preambleTE);
479 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
483 void PreambleModule::update(BufferParams const & params, BufferId id)
485 QString preamble = toqstr(params.preamble);
486 // Nothing to do if the params and preamble are unchanged.
487 if (id == current_id_
488 && preamble == preambleTE->document()->toPlainText())
491 QTextCursor cur = preambleTE->textCursor();
492 // Save the coords before switching to the new one.
493 preamble_coords_[current_id_] =
494 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
496 // Save the params address for further use.
498 preambleTE->document()->setPlainText(preamble);
499 Coords::const_iterator it = preamble_coords_.find(current_id_);
500 if (it == preamble_coords_.end())
501 // First time we open this one.
502 preamble_coords_[current_id_] = make_pair(0, 0);
504 // Restore saved coords.
505 QTextCursor cur = preambleTE->textCursor();
506 cur.setPosition(it->second.first);
507 preambleTE->setTextCursor(cur);
508 preambleTE->verticalScrollBar()->setValue(it->second.second);
513 void PreambleModule::apply(BufferParams & params)
515 params.preamble = fromqstr(preambleTE->document()->toPlainText());
519 void PreambleModule::closeEvent(QCloseEvent * e)
521 // Save the coords before closing.
522 QTextCursor cur = preambleTE->textCursor();
523 preamble_coords_[current_id_] =
524 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
529 /////////////////////////////////////////////////////////////////////
533 /////////////////////////////////////////////////////////////////////
536 LocalLayout::LocalLayout() : current_id_(0), is_valid_(false)
538 connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
539 connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
543 void LocalLayout::update(BufferParams const & params, BufferId id)
545 QString layout = toqstr(params.local_layout);
546 // Nothing to do if the params and preamble are unchanged.
547 if (id == current_id_
548 && layout == locallayoutTE->document()->toPlainText())
551 // Save the params address for further use.
553 locallayoutTE->document()->setPlainText(layout);
558 void LocalLayout::apply(BufferParams & params)
560 string const layout = fromqstr(locallayoutTE->document()->toPlainText());
561 params.local_layout = layout;
565 void LocalLayout::textChanged()
567 static const QString unknown = qt_("Press button to check validity...");
570 infoLB->setText(unknown);
571 validatePB->setEnabled(true);
576 void LocalLayout::validate() {
577 static const QString valid = qt_("Layout is valid!");
578 static const QString vtext =
579 toqstr("<p style=\"font-weight: bold; \">")
580 + valid + toqstr("</p>");
581 static const QString invalid = qt_("Layout is invalid!");
582 static const QString ivtext =
583 toqstr("<p style=\"color: #c00000; font-weight: bold; \">")
584 + invalid + toqstr("</p>");
586 string const layout =
587 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
588 if (layout.empty()) {
592 is_valid_ = TextClass::validate(layout);
593 infoLB->setText(is_valid_ ? vtext : ivtext);
595 validatePB->setEnabled(false);
599 void LocalLayout::validatePressed() {
605 /////////////////////////////////////////////////////////////////////
609 /////////////////////////////////////////////////////////////////////
612 GuiDocument::GuiDocument(GuiView & lv)
613 : GuiDialog(lv, "document", qt_("Document Settings"))
617 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
618 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
619 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
620 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
622 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
623 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
625 // Manage the restore, ok, apply, restore and cancel/close buttons
626 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
628 bc().setApply(applyPB);
629 bc().setCancel(closePB);
630 bc().setRestore(restorePB);
634 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
635 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
636 this, SLOT(change_adaptor()));
637 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
638 this, SLOT(setLSpacing(int)));
639 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
640 this, SLOT(change_adaptor()));
642 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
643 this, SLOT(change_adaptor()));
644 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
645 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
646 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
647 this, SLOT(change_adaptor()));
648 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
649 this, SLOT(setIndent(int)));
650 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
651 this, SLOT(change_adaptor()));
652 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
653 this, SLOT(change_adaptor()));
655 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
656 this, SLOT(change_adaptor()));
657 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
658 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
659 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
660 this, SLOT(change_adaptor()));
661 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
662 this, SLOT(setSkip(int)));
663 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
664 this, SLOT(change_adaptor()));
665 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
666 this, SLOT(change_adaptor()));
668 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
669 this, SLOT(enableIndent(bool)));
670 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
671 this, SLOT(enableSkip(bool)));
673 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
674 this, SLOT(change_adaptor()));
675 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
676 this, SLOT(setColSep()));
678 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
679 textLayoutModule->lspacingLE));
680 textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
681 textLayoutModule->indentLE));
682 textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
683 textLayoutModule->skipLE));
685 textLayoutModule->indentCO->addItem(qt_("Default"));
686 textLayoutModule->indentCO->addItem(qt_("Custom"));
687 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
688 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
689 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
690 textLayoutModule->skipCO->addItem(qt_("Custom"));
691 textLayoutModule->lspacingCO->insertItem(
692 Spacing::Single, qt_("Single"));
693 textLayoutModule->lspacingCO->insertItem(
694 Spacing::Onehalf, qt_("OneHalf"));
695 textLayoutModule->lspacingCO->insertItem(
696 Spacing::Double, qt_("Double"));
697 textLayoutModule->lspacingCO->insertItem(
698 Spacing::Other, qt_("Custom"));
699 // initialize the length validator
700 bc().addCheckedLineEdit(textLayoutModule->indentLE);
701 bc().addCheckedLineEdit(textLayoutModule->skipLE);
704 // master/child handling
705 masterChildModule = new UiWidget<Ui::MasterChildUi>;
707 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
708 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
709 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
710 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
711 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
712 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
713 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
714 this, SLOT(change_adaptor()));
715 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
716 this, SLOT(change_adaptor()));
717 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
718 this, SLOT(change_adaptor()));
719 masterChildModule->childrenTW->setColumnCount(2);
720 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
721 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
722 masterChildModule->childrenTW->resizeColumnToContents(1);
723 masterChildModule->childrenTW->resizeColumnToContents(2);
727 outputModule = new UiWidget<Ui::OutputUi>;
729 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
730 this, SLOT(change_adaptor()));
731 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
732 this, SLOT(change_adaptor()));
733 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
734 this, SLOT(change_adaptor()));
735 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
736 this, SLOT(change_adaptor()));
738 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
739 this, SLOT(change_adaptor()));
740 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
741 this, SLOT(change_adaptor()));
742 outputModule->synccustomCB->addItem("");
743 outputModule->synccustomCB->addItem("\\synctex=1");
744 outputModule->synccustomCB->addItem("\\synctex=-1");
745 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
748 fontModule = new UiWidget<Ui::FontUi>;
749 connect(fontModule->osFontsCB, SIGNAL(clicked()),
750 this, SLOT(change_adaptor()));
751 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
752 this, SLOT(osFontsChanged(bool)));
753 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
754 this, SLOT(change_adaptor()));
755 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
756 this, SLOT(romanChanged(int)));
757 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
758 this, SLOT(change_adaptor()));
759 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
760 this, SLOT(sansChanged(int)));
761 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
762 this, SLOT(change_adaptor()));
763 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
764 this, SLOT(ttChanged(int)));
765 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
766 this, SLOT(change_adaptor()));
767 connect(fontModule->fontencCO, SIGNAL(activated(int)),
768 this, SLOT(change_adaptor()));
769 connect(fontModule->fontencCO, SIGNAL(activated(int)),
770 this, SLOT(fontencChanged(int)));
771 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
772 this, SLOT(change_adaptor()));
773 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
774 this, SLOT(change_adaptor()));
775 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
776 this, SLOT(change_adaptor()));
777 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
778 this, SLOT(change_adaptor()));
779 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
780 this, SLOT(change_adaptor()));
781 connect(fontModule->fontScCB, SIGNAL(clicked()),
782 this, SLOT(change_adaptor()));
783 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
784 this, SLOT(change_adaptor()));
788 fontModule->fontsizeCO->addItem(qt_("Default"));
789 fontModule->fontsizeCO->addItem(qt_("10"));
790 fontModule->fontsizeCO->addItem(qt_("11"));
791 fontModule->fontsizeCO->addItem(qt_("12"));
793 fontModule->fontencCO->addItem(qt_("Default"));
794 fontModule->fontencCO->addItem(qt_("Custom"));
795 fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
797 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
798 fontModule->fontsDefaultCO->addItem(
799 qt_(GuiDocument::fontfamilies_gui[n]));
801 if (!LaTeXFeatures::isAvailable("fontspec"))
802 fontModule->osFontsCB->setToolTip(
803 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
804 "You need to install the package \"fontspec\" to use this feature"));
808 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
809 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
810 this, SLOT(papersizeChanged(int)));
811 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
812 this, SLOT(papersizeChanged(int)));
813 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
814 this, SLOT(change_adaptor()));
815 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
816 this, SLOT(change_adaptor()));
817 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
818 this, SLOT(change_adaptor()));
819 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
820 this, SLOT(change_adaptor()));
821 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
822 this, SLOT(change_adaptor()));
823 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
824 this, SLOT(change_adaptor()));
825 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
826 this, SLOT(change_adaptor()));
827 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
828 this, SLOT(change_adaptor()));
829 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
830 this, SLOT(change_adaptor()));
831 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
832 this, SLOT(change_adaptor()));
834 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
835 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
836 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
837 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
838 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
839 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
840 pageLayoutModule->paperheightL);
841 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
842 pageLayoutModule->paperwidthL);
844 QComboBox * cb = pageLayoutModule->papersizeCO;
845 cb->addItem(qt_("Default"));
846 cb->addItem(qt_("Custom"));
847 cb->addItem(qt_("US letter"));
848 cb->addItem(qt_("US legal"));
849 cb->addItem(qt_("US executive"));
850 cb->addItem(qt_("A0"));
851 cb->addItem(qt_("A1"));
852 cb->addItem(qt_("A2"));
853 cb->addItem(qt_("A3"));
854 cb->addItem(qt_("A4"));
855 cb->addItem(qt_("A5"));
856 cb->addItem(qt_("A6"));
857 cb->addItem(qt_("B0"));
858 cb->addItem(qt_("B1"));
859 cb->addItem(qt_("B2"));
860 cb->addItem(qt_("B3"));
861 cb->addItem(qt_("B4"));
862 cb->addItem(qt_("B5"));
863 cb->addItem(qt_("B6"));
864 cb->addItem(qt_("C0"));
865 cb->addItem(qt_("C1"));
866 cb->addItem(qt_("C2"));
867 cb->addItem(qt_("C3"));
868 cb->addItem(qt_("C4"));
869 cb->addItem(qt_("C5"));
870 cb->addItem(qt_("C6"));
871 cb->addItem(qt_("JIS B0"));
872 cb->addItem(qt_("JIS B1"));
873 cb->addItem(qt_("JIS B2"));
874 cb->addItem(qt_("JIS B3"));
875 cb->addItem(qt_("JIS B4"));
876 cb->addItem(qt_("JIS B5"));
877 cb->addItem(qt_("JIS B6"));
878 // remove the %-items from the unit choice
879 pageLayoutModule->paperwidthUnitCO->noPercents();
880 pageLayoutModule->paperheightUnitCO->noPercents();
881 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
882 pageLayoutModule->paperheightLE));
883 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
884 pageLayoutModule->paperwidthLE));
888 marginsModule = new UiWidget<Ui::MarginsUi>;
889 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
890 this, SLOT(setCustomMargins(bool)));
891 connect(marginsModule->marginCB, SIGNAL(clicked()),
892 this, SLOT(change_adaptor()));
893 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
894 this, SLOT(change_adaptor()));
895 connect(marginsModule->topUnit, SIGNAL(activated(int)),
896 this, SLOT(change_adaptor()));
897 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
898 this, SLOT(change_adaptor()));
899 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
900 this, SLOT(change_adaptor()));
901 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
902 this, SLOT(change_adaptor()));
903 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
904 this, SLOT(change_adaptor()));
905 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
906 this, SLOT(change_adaptor()));
907 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
908 this, SLOT(change_adaptor()));
909 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
910 this, SLOT(change_adaptor()));
911 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
912 this, SLOT(change_adaptor()));
913 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
914 this, SLOT(change_adaptor()));
915 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
916 this, SLOT(change_adaptor()));
917 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
918 this, SLOT(change_adaptor()));
919 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
920 this, SLOT(change_adaptor()));
921 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
922 this, SLOT(change_adaptor()));
923 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
924 this, SLOT(change_adaptor()));
925 marginsModule->topLE->setValidator(unsignedLengthValidator(
926 marginsModule->topLE));
927 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
928 marginsModule->bottomLE));
929 marginsModule->innerLE->setValidator(unsignedLengthValidator(
930 marginsModule->innerLE));
931 marginsModule->outerLE->setValidator(unsignedLengthValidator(
932 marginsModule->outerLE));
933 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
934 marginsModule->headsepLE));
935 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
936 marginsModule->headheightLE));
937 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
938 marginsModule->footskipLE));
939 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
940 marginsModule->columnsepLE));
942 bc().addCheckedLineEdit(marginsModule->topLE,
943 marginsModule->topL);
944 bc().addCheckedLineEdit(marginsModule->bottomLE,
945 marginsModule->bottomL);
946 bc().addCheckedLineEdit(marginsModule->innerLE,
947 marginsModule->innerL);
948 bc().addCheckedLineEdit(marginsModule->outerLE,
949 marginsModule->outerL);
950 bc().addCheckedLineEdit(marginsModule->headsepLE,
951 marginsModule->headsepL);
952 bc().addCheckedLineEdit(marginsModule->headheightLE,
953 marginsModule->headheightL);
954 bc().addCheckedLineEdit(marginsModule->footskipLE,
955 marginsModule->footskipL);
956 bc().addCheckedLineEdit(marginsModule->columnsepLE,
957 marginsModule->columnsepL);
961 langModule = new UiWidget<Ui::LanguageUi>;
962 connect(langModule->languageCO, SIGNAL(activated(int)),
963 this, SLOT(change_adaptor()));
964 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
965 this, SLOT(change_adaptor()));
966 connect(langModule->otherencodingRB, SIGNAL(clicked()),
967 this, SLOT(change_adaptor()));
968 connect(langModule->encodingCO, SIGNAL(activated(int)),
969 this, SLOT(change_adaptor()));
970 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
971 this, SLOT(change_adaptor()));
972 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
973 this, SLOT(change_adaptor()));
974 connect(langModule->languagePackageED, SIGNAL(textChanged(QString)),
975 this, SLOT(change_adaptor()));
976 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
977 this, SLOT(languagePackageChanged(int)));
979 QAbstractItemModel * language_model = guiApp->languageModel();
980 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
981 language_model->sort(0);
982 langModule->languageCO->setModel(language_model);
983 langModule->languageCO->setModelColumn(0);
985 // Always put the default encoding in the first position.
986 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
987 QStringList encodinglist;
988 Encodings::const_iterator it = encodings.begin();
989 Encodings::const_iterator const end = encodings.end();
990 for (; it != end; ++it)
991 encodinglist.append(qt_(it->guiName()));
993 langModule->encodingCO->addItems(encodinglist);
995 langModule->quoteStyleCO->addItem(qt_("``text''"));
996 langModule->quoteStyleCO->addItem(qt_("''text''"));
997 langModule->quoteStyleCO->addItem(qt_(",,text``"));
998 langModule->quoteStyleCO->addItem(qt_(",,text''"));
999 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
1000 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
1002 langModule->languagePackageCO->addItem(
1003 qt_("Default"), toqstr("default"));
1004 langModule->languagePackageCO->addItem(
1005 qt_("Automatic"), toqstr("auto"));
1006 langModule->languagePackageCO->addItem(
1007 qt_("Always Babel"), toqstr("babel"));
1008 langModule->languagePackageCO->addItem(
1009 qt_("Custom"), toqstr("custom"));
1010 langModule->languagePackageCO->addItem(
1011 qt_("None[[language package]]"), toqstr("none"));
1015 colorModule = new UiWidget<Ui::ColorUi>;
1016 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1017 this, SLOT(changeFontColor()));
1018 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1019 this, SLOT(deleteFontColor()));
1020 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1021 this, SLOT(changeNoteFontColor()));
1022 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1023 this, SLOT(deleteNoteFontColor()));
1024 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1025 this, SLOT(changeBackgroundColor()));
1026 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1027 this, SLOT(deleteBackgroundColor()));
1028 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1029 this, SLOT(changeBoxBackgroundColor()));
1030 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1031 this, SLOT(deleteBoxBackgroundColor()));
1035 numberingModule = new UiWidget<Ui::NumberingUi>;
1036 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1037 this, SLOT(change_adaptor()));
1038 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1039 this, SLOT(change_adaptor()));
1040 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1041 this, SLOT(updateNumbering()));
1042 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1043 this, SLOT(updateNumbering()));
1044 numberingModule->tocTW->setColumnCount(3);
1045 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1046 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1047 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1048 numberingModule->tocTW->header()->setResizeMode(QHeaderView::ResizeToContents);
1052 biblioModule = new UiWidget<Ui::BiblioUi>;
1053 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1054 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1055 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1056 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1057 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1058 this, SLOT(change_adaptor()));
1059 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1060 this, SLOT(change_adaptor()));
1061 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1062 this, SLOT(change_adaptor()));
1063 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1064 this, SLOT(change_adaptor()));
1065 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1066 this, SLOT(change_adaptor()));
1067 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1068 this, SLOT(bibtexChanged(int)));
1069 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
1070 this, SLOT(change_adaptor()));
1072 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1073 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1074 biblioModule->citeStyleCO->setCurrentIndex(0);
1076 // NOTE: we do not provide "custom" here for security reasons!
1077 biblioModule->bibtexCO->clear();
1078 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1079 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1080 it != lyxrc.bibtex_alternatives.end(); ++it) {
1081 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1082 biblioModule->bibtexCO->addItem(command, command);
1087 indicesModule = new GuiIndices;
1088 connect(indicesModule, SIGNAL(changed()),
1089 this, SLOT(change_adaptor()));
1093 mathsModule = new UiWidget<Ui::MathsUi>;
1094 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1095 mathsModule->amsCB, SLOT(setDisabled(bool)));
1096 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1097 mathsModule->esintCB, SLOT(setDisabled(bool)));
1098 connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1099 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1100 connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1101 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1103 connect(mathsModule->amsCB, SIGNAL(clicked()),
1104 this, SLOT(change_adaptor()));
1105 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1106 this, SLOT(change_adaptor()));
1107 connect(mathsModule->esintCB, SIGNAL(clicked()),
1108 this, SLOT(change_adaptor()));
1109 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1110 this, SLOT(change_adaptor()));
1111 connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1112 this, SLOT(change_adaptor()));
1113 connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1114 this, SLOT(change_adaptor()));
1115 connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1116 this, SLOT(change_adaptor()));
1117 connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1118 this, SLOT(change_adaptor()));
1122 latexModule = new UiWidget<Ui::LaTeXUi>;
1123 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1124 this, SLOT(change_adaptor()));
1125 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1126 this, SLOT(change_adaptor()));
1127 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1128 this, SLOT(change_adaptor()));
1129 connect(latexModule->classCO, SIGNAL(activated(int)),
1130 this, SLOT(classChanged()));
1131 connect(latexModule->classCO, SIGNAL(activated(int)),
1132 this, SLOT(change_adaptor()));
1133 connect(latexModule->layoutPB, SIGNAL(clicked()),
1134 this, SLOT(browseLayout()));
1135 connect(latexModule->layoutPB, SIGNAL(clicked()),
1136 this, SLOT(change_adaptor()));
1137 connect(latexModule->childDocGB, SIGNAL(clicked()),
1138 this, SLOT(change_adaptor()));
1139 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1140 this, SLOT(change_adaptor()));
1141 connect(latexModule->childDocPB, SIGNAL(clicked()),
1142 this, SLOT(browseMaster()));
1143 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1144 this, SLOT(change_adaptor()));
1145 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1146 this, SLOT(change_adaptor()));
1148 // postscript drivers
1149 for (int n = 0; tex_graphics[n][0]; ++n) {
1150 QString enc = qt_(tex_graphics_gui[n]);
1151 latexModule->psdriverCO->addItem(enc);
1154 latexModule->classCO->setModel(&classes_model_);
1155 LayoutFileList const & bcl = LayoutFileList::get();
1156 vector<LayoutFileIndex> classList = bcl.classList();
1157 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1159 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1160 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1161 for (int i = 0; cit != cen; ++cit, ++i) {
1162 LayoutFile const & tc = bcl[*cit];
1163 docstring item = (tc.isTeXClassAvailable()) ?
1164 from_utf8(tc.description()) :
1165 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1166 classes_model_.insertRow(i, toqstr(item), *cit);
1171 branchesModule = new GuiBranches;
1172 connect(branchesModule, SIGNAL(changed()),
1173 this, SLOT(change_adaptor()));
1174 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1175 this, SLOT(branchesRename(docstring const &, docstring const &)));
1176 updateUnknownBranches();
1180 preambleModule = new PreambleModule;
1181 connect(preambleModule, SIGNAL(changed()),
1182 this, SLOT(change_adaptor()));
1184 localLayout = new LocalLayout;
1185 connect(localLayout, SIGNAL(changed()),
1186 this, SLOT(change_adaptor()));
1190 bulletsModule = new BulletsModule;
1191 connect(bulletsModule, SIGNAL(changed()),
1192 this, SLOT(change_adaptor()));
1196 modulesModule = new UiWidget<Ui::ModulesUi>;
1197 modulesModule->availableLV->header()->setVisible(false);
1198 modulesModule->availableLV->header()->setResizeMode(QHeaderView::ResizeToContents);
1199 modulesModule->availableLV->header()->setStretchLastSection(false);
1201 new ModuleSelectionManager(modulesModule->availableLV,
1202 modulesModule->selectedLV,
1203 modulesModule->addPB, modulesModule->deletePB,
1204 modulesModule->upPB, modulesModule->downPB,
1205 availableModel(), selectedModel(), this);
1206 connect(selectionManager, SIGNAL(updateHook()),
1207 this, SLOT(updateModuleInfo()));
1208 connect(selectionManager, SIGNAL(updateHook()),
1209 this, SLOT(change_adaptor()));
1210 connect(selectionManager, SIGNAL(selectionChanged()),
1211 this, SLOT(modulesChanged()));
1215 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1216 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1217 this, SLOT(change_adaptor()));
1218 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1219 this, SLOT(change_adaptor()));
1220 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1221 this, SLOT(change_adaptor()));
1222 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1223 this, SLOT(change_adaptor()));
1224 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1225 this, SLOT(change_adaptor()));
1226 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1227 this, SLOT(change_adaptor()));
1228 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1229 this, SLOT(change_adaptor()));
1230 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1231 this, SLOT(change_adaptor()));
1232 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1233 this, SLOT(change_adaptor()));
1234 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1235 this, SLOT(change_adaptor()));
1236 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1237 this, SLOT(change_adaptor()));
1238 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1239 this, SLOT(change_adaptor()));
1240 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1241 this, SLOT(change_adaptor()));
1242 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1243 this, SLOT(change_adaptor()));
1244 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1245 this, SLOT(change_adaptor()));
1246 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1247 this, SLOT(change_adaptor()));
1249 for (int i = 0; backref_opts[i][0]; ++i)
1250 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1254 floatModule = new FloatPlacement;
1255 connect(floatModule, SIGNAL(changed()),
1256 this, SLOT(change_adaptor()));
1260 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1261 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1262 this, SLOT(change_adaptor()));
1263 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1264 this, SLOT(change_adaptor()));
1265 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1266 this, SLOT(setListingsMessage()));
1267 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1268 this, SLOT(setListingsMessage()));
1269 listingsModule->listingsTB->setPlainText(
1270 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1274 docPS->addPanel(latexModule, qt_("Document Class"));
1275 docPS->addPanel(masterChildModule, qt_("Child Documents"));
1276 docPS->addPanel(modulesModule, qt_("Modules"));
1277 docPS->addPanel(localLayout, qt_("Local Layout"));
1278 docPS->addPanel(fontModule, qt_("Fonts"));
1279 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1280 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1281 docPS->addPanel(marginsModule, qt_("Page Margins"));
1282 docPS->addPanel(langModule, qt_("Language"));
1283 docPS->addPanel(colorModule, qt_("Colors"));
1284 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1285 docPS->addPanel(biblioModule, qt_("Bibliography"));
1286 docPS->addPanel(indicesModule, qt_("Indexes"));
1287 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1288 docPS->addPanel(mathsModule, qt_("Math Options"));
1289 docPS->addPanel(floatModule, qt_("Float Placement"));
1290 docPS->addPanel(listingsModule, qt_("Listings"));
1291 docPS->addPanel(bulletsModule, qt_("Bullets"));
1292 docPS->addPanel(branchesModule, qt_("Branches"));
1293 docPS->addPanel(outputModule, qt_("Output"));
1294 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1295 docPS->setCurrentPanel(qt_("Document Class"));
1296 // FIXME: hack to work around resizing bug in Qt >= 4.2
1297 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1298 #if QT_VERSION >= 0x040200
1299 docPS->updateGeometry();
1304 void GuiDocument::saveDefaultClicked()
1310 void GuiDocument::useDefaultsClicked()
1316 void GuiDocument::change_adaptor()
1322 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1327 string child = fromqstr(item->text(0));
1331 if (std::find(includeonlys_.begin(),
1332 includeonlys_.end(), child) != includeonlys_.end())
1333 includeonlys_.remove(child);
1335 includeonlys_.push_back(child);
1337 updateIncludeonlys();
1342 QString GuiDocument::validateListingsParameters()
1344 // use a cache here to avoid repeated validation
1345 // of the same parameters
1346 static string param_cache;
1347 static QString msg_cache;
1349 if (listingsModule->bypassCB->isChecked())
1352 string params = fromqstr(listingsModule->listingsED->toPlainText());
1353 if (params != param_cache) {
1354 param_cache = params;
1355 msg_cache = toqstr(InsetListingsParams(params).validate());
1361 void GuiDocument::setListingsMessage()
1363 static bool isOK = true;
1364 QString msg = validateListingsParameters();
1365 if (msg.isEmpty()) {
1369 // listingsTB->setTextColor("black");
1370 listingsModule->listingsTB->setPlainText(
1371 qt_("Input listings parameters below. "
1372 "Enter ? for a list of parameters."));
1375 // listingsTB->setTextColor("red");
1376 listingsModule->listingsTB->setPlainText(msg);
1381 void GuiDocument::setLSpacing(int item)
1383 textLayoutModule->lspacingLE->setEnabled(item == 3);
1387 void GuiDocument::setIndent(int item)
1389 bool const enable = (item == 1);
1390 textLayoutModule->indentLE->setEnabled(enable);
1391 textLayoutModule->indentLengthCO->setEnabled(enable);
1392 textLayoutModule->skipLE->setEnabled(false);
1393 textLayoutModule->skipLengthCO->setEnabled(false);
1398 void GuiDocument::enableIndent(bool indent)
1400 textLayoutModule->skipLE->setEnabled(!indent);
1401 textLayoutModule->skipLengthCO->setEnabled(!indent);
1403 setIndent(textLayoutModule->indentCO->currentIndex());
1407 void GuiDocument::setSkip(int item)
1409 bool const enable = (item == 3);
1410 textLayoutModule->skipLE->setEnabled(enable);
1411 textLayoutModule->skipLengthCO->setEnabled(enable);
1416 void GuiDocument::enableSkip(bool skip)
1418 textLayoutModule->indentLE->setEnabled(!skip);
1419 textLayoutModule->indentLengthCO->setEnabled(!skip);
1421 setSkip(textLayoutModule->skipCO->currentIndex());
1425 void GuiDocument::setMargins()
1427 bool const extern_geometry =
1428 documentClass().provides("geometry");
1429 marginsModule->marginCB->setEnabled(!extern_geometry);
1430 if (extern_geometry) {
1431 marginsModule->marginCB->setChecked(false);
1432 setCustomMargins(true);
1434 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1435 setCustomMargins(!bp_.use_geometry);
1440 void GuiDocument::papersizeChanged(int paper_size)
1442 setCustomPapersize(paper_size == 1);
1446 void GuiDocument::setCustomPapersize(bool custom)
1448 pageLayoutModule->paperwidthL->setEnabled(custom);
1449 pageLayoutModule->paperwidthLE->setEnabled(custom);
1450 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1451 pageLayoutModule->paperheightL->setEnabled(custom);
1452 pageLayoutModule->paperheightLE->setEnabled(custom);
1453 pageLayoutModule->paperheightLE->setFocus();
1454 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1458 void GuiDocument::setColSep()
1460 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1464 void GuiDocument::setCustomMargins(bool custom)
1466 marginsModule->topL->setEnabled(!custom);
1467 marginsModule->topLE->setEnabled(!custom);
1468 marginsModule->topUnit->setEnabled(!custom);
1470 marginsModule->bottomL->setEnabled(!custom);
1471 marginsModule->bottomLE->setEnabled(!custom);
1472 marginsModule->bottomUnit->setEnabled(!custom);
1474 marginsModule->innerL->setEnabled(!custom);
1475 marginsModule->innerLE->setEnabled(!custom);
1476 marginsModule->innerUnit->setEnabled(!custom);
1478 marginsModule->outerL->setEnabled(!custom);
1479 marginsModule->outerLE->setEnabled(!custom);
1480 marginsModule->outerUnit->setEnabled(!custom);
1482 marginsModule->headheightL->setEnabled(!custom);
1483 marginsModule->headheightLE->setEnabled(!custom);
1484 marginsModule->headheightUnit->setEnabled(!custom);
1486 marginsModule->headsepL->setEnabled(!custom);
1487 marginsModule->headsepLE->setEnabled(!custom);
1488 marginsModule->headsepUnit->setEnabled(!custom);
1490 marginsModule->footskipL->setEnabled(!custom);
1491 marginsModule->footskipLE->setEnabled(!custom);
1492 marginsModule->footskipUnit->setEnabled(!custom);
1494 bool const enableColSep = !custom &&
1495 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1496 marginsModule->columnsepL->setEnabled(enableColSep);
1497 marginsModule->columnsepLE->setEnabled(enableColSep);
1498 marginsModule->columnsepUnit->setEnabled(enableColSep);
1502 void GuiDocument::changeBackgroundColor()
1504 QColor const & newColor = QColorDialog::getColor(
1505 rgb2qcolor(set_backgroundcolor), asQWidget());
1506 if (!newColor.isValid())
1508 // set the button color and text
1509 colorModule->backgroundPB->setStyleSheet(
1510 colorButtonStyleSheet(newColor));
1511 colorModule->backgroundPB->setText(qt_("&Change..."));
1513 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1514 is_backgroundcolor = true;
1519 void GuiDocument::deleteBackgroundColor()
1521 // set the button color back to default by setting an empty StyleSheet
1522 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1523 // change button text
1524 colorModule->backgroundPB->setText(qt_("&Default..."));
1525 // save default color (white)
1526 set_backgroundcolor = rgbFromHexName("#ffffff");
1527 is_backgroundcolor = false;
1532 void GuiDocument::changeFontColor()
1534 QColor const & newColor = QColorDialog::getColor(
1535 rgb2qcolor(set_fontcolor), asQWidget());
1536 if (!newColor.isValid())
1538 // set the button color and text
1539 colorModule->fontColorPB->setStyleSheet(
1540 colorButtonStyleSheet(newColor));
1541 colorModule->fontColorPB->setText(qt_("&Change..."));
1543 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1544 is_fontcolor = true;
1549 void GuiDocument::deleteFontColor()
1551 // set the button color back to default by setting an empty StyleSheet
1552 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1553 // change button text
1554 colorModule->fontColorPB->setText(qt_("&Default..."));
1555 // save default color (black)
1556 set_fontcolor = rgbFromHexName("#000000");
1557 is_fontcolor = false;
1562 void GuiDocument::changeNoteFontColor()
1564 QColor const & newColor = QColorDialog::getColor(
1565 rgb2qcolor(set_notefontcolor), asQWidget());
1566 if (!newColor.isValid())
1568 // set the button color
1569 colorModule->noteFontColorPB->setStyleSheet(
1570 colorButtonStyleSheet(newColor));
1572 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1577 void GuiDocument::deleteNoteFontColor()
1579 // set the button color back to pref
1580 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1581 colorModule->noteFontColorPB->setStyleSheet(
1582 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1587 void GuiDocument::changeBoxBackgroundColor()
1589 QColor const & newColor = QColorDialog::getColor(
1590 rgb2qcolor(set_boxbgcolor), asQWidget());
1591 if (!newColor.isValid())
1593 // set the button color
1594 colorModule->boxBackgroundPB->setStyleSheet(
1595 colorButtonStyleSheet(newColor));
1597 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1602 void GuiDocument::deleteBoxBackgroundColor()
1604 // set the button color back to pref
1605 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1606 colorModule->boxBackgroundPB->setStyleSheet(
1607 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1612 void GuiDocument::osFontsChanged(bool nontexfonts)
1614 bool const tex_fonts = !nontexfonts;
1616 updateDefaultFormat();
1617 langModule->encodingCO->setEnabled(tex_fonts &&
1618 !langModule->defaultencodingRB->isChecked());
1619 langModule->defaultencodingRB->setEnabled(tex_fonts);
1620 langModule->otherencodingRB->setEnabled(tex_fonts);
1622 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1623 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1624 fontModule->cjkFontLE->setEnabled(tex_fonts);
1625 fontModule->cjkFontLA->setEnabled(tex_fonts);
1628 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1629 bool scaleable = providesScale(font);
1630 fontModule->scaleSansSB->setEnabled(scaleable);
1631 fontModule->scaleSansLA->setEnabled(scaleable);
1633 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1634 scaleable = providesScale(font);
1635 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1636 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1638 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1639 fontModule->fontScCB->setEnabled(providesSC(font));
1640 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1642 fontModule->fontencLA->setEnabled(tex_fonts);
1643 fontModule->fontencCO->setEnabled(tex_fonts);
1645 fontModule->fontencLE->setEnabled(false);
1647 fontencChanged(fontModule->fontencCO->currentIndex());
1651 void GuiDocument::updateFontsize(string const & items, string const & sel)
1653 fontModule->fontsizeCO->clear();
1654 fontModule->fontsizeCO->addItem(qt_("Default"));
1656 for (int n = 0; !token(items,'|',n).empty(); ++n)
1657 fontModule->fontsizeCO->
1658 addItem(toqstr(token(items,'|',n)));
1660 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1661 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1662 fontModule->fontsizeCO->setCurrentIndex(n);
1669 void GuiDocument::updateFontlist()
1671 fontModule->fontsRomanCO->clear();
1672 fontModule->fontsSansCO->clear();
1673 fontModule->fontsTypewriterCO->clear();
1675 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1676 if (fontModule->osFontsCB->isChecked()) {
1677 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1678 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1679 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1681 QFontDatabase fontdb;
1682 QStringList families(fontdb.families());
1683 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1684 fontModule->fontsRomanCO->addItem(*it, *it);
1685 fontModule->fontsSansCO->addItem(*it, *it);
1686 fontModule->fontsTypewriterCO->addItem(*it, *it);
1691 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1692 QString font = qt_(tex_fonts_roman_gui[n]);
1693 if (!isFontAvailable(tex_fonts_roman[n]))
1694 font += qt_(" (not installed)");
1695 fontModule->fontsRomanCO->addItem(font, qt_(tex_fonts_roman[n]));
1697 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1698 QString font = qt_(tex_fonts_sans_gui[n]);
1699 if (!isFontAvailable(tex_fonts_sans[n]))
1700 font += qt_(" (not installed)");
1701 fontModule->fontsSansCO->addItem(font, qt_(tex_fonts_sans[n]));
1703 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1704 QString font = qt_(tex_fonts_monospaced_gui[n]);
1705 if (!isFontAvailable(tex_fonts_monospaced[n]))
1706 font += qt_(" (not installed)");
1707 fontModule->fontsTypewriterCO->addItem(font, qt_(tex_fonts_monospaced[n]));
1712 void GuiDocument::fontencChanged(int item)
1714 fontModule->fontencLE->setEnabled(item == 1);
1718 void GuiDocument::romanChanged(int item)
1720 if (fontModule->osFontsCB->isChecked())
1722 string const font = tex_fonts_roman[item];
1723 fontModule->fontScCB->setEnabled(providesSC(font));
1724 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1728 void GuiDocument::sansChanged(int item)
1730 if (fontModule->osFontsCB->isChecked())
1732 string const font = tex_fonts_sans[item];
1733 bool scaleable = providesScale(font);
1734 fontModule->scaleSansSB->setEnabled(scaleable);
1735 fontModule->scaleSansLA->setEnabled(scaleable);
1739 void GuiDocument::ttChanged(int item)
1741 if (fontModule->osFontsCB->isChecked())
1743 string const font = tex_fonts_monospaced[item];
1744 bool scaleable = providesScale(font);
1745 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1746 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1750 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1753 pageLayoutModule->pagestyleCO->clear();
1754 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1756 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1757 string style = token(items, '|', n);
1758 QString style_gui = qt_(style);
1759 pagestyles.push_back(pair<string, QString>(style, style_gui));
1760 pageLayoutModule->pagestyleCO->addItem(style_gui);
1763 if (sel == "default") {
1764 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1770 for (size_t i = 0; i < pagestyles.size(); ++i)
1771 if (pagestyles[i].first == sel)
1772 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1775 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1779 void GuiDocument::browseLayout()
1781 QString const label1 = qt_("Layouts|#o#O");
1782 QString const dir1 = toqstr(lyxrc.document_path);
1783 QStringList const filter(qt_("LyX Layout (*.layout)"));
1784 QString file = browseRelFile(QString(), bufferFilePath(),
1785 qt_("Local layout file"), filter, false,
1788 if (!file.endsWith(".layout"))
1791 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1792 fromqstr(bufferFilePath()));
1794 int const ret = Alert::prompt(_("Local layout file"),
1795 _("The layout file you have selected is a local layout\n"
1796 "file, not one in the system or user directory. Your\n"
1797 "document may not work with this layout if you do not\n"
1798 "keep the layout file in the document directory."),
1799 1, 1, _("&Set Layout"), _("&Cancel"));
1803 // load the layout file
1804 LayoutFileList & bcl = LayoutFileList::get();
1805 string classname = layoutFile.onlyFileName();
1806 // this will update an existing layout if that layout has been loaded before.
1807 LayoutFileIndex name = bcl.addLocalLayout(
1808 classname.substr(0, classname.size() - 7),
1809 layoutFile.onlyPath().absFileName());
1812 Alert::error(_("Error"),
1813 _("Unable to read local layout file."));
1817 // do not trigger classChanged if there is no change.
1818 if (latexModule->classCO->currentText() == toqstr(name))
1822 int idx = latexModule->classCO->findText(toqstr(name));
1824 classes_model_.insertRow(0, toqstr(name), name);
1825 latexModule->classCO->setCurrentIndex(0);
1827 latexModule->classCO->setCurrentIndex(idx);
1833 void GuiDocument::browseMaster()
1835 QString const title = qt_("Select master document");
1836 QString const dir1 = toqstr(lyxrc.document_path);
1837 QString const old = latexModule->childDocLE->text();
1838 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1839 QStringList const filter(qt_("LyX Files (*.lyx)"));
1840 QString file = browseRelFile(old, docpath, title, filter, false,
1841 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1843 if (!file.isEmpty())
1844 latexModule->childDocLE->setText(file);
1848 void GuiDocument::classChanged()
1850 int idx = latexModule->classCO->currentIndex();
1853 string const classname = classes_model_.getIDString(idx);
1855 // check whether the selected modules have changed.
1856 bool modules_changed = false;
1857 unsigned int const srows = selectedModel()->rowCount();
1858 if (srows != bp_.getModules().size())
1859 modules_changed = true;
1861 list<string>::const_iterator mit = bp_.getModules().begin();
1862 list<string>::const_iterator men = bp_.getModules().end();
1863 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1864 if (selectedModel()->getIDString(i) != *mit) {
1865 modules_changed = true;
1870 if (modules_changed || lyxrc.auto_reset_options) {
1871 if (applyPB->isEnabled()) {
1872 int const ret = Alert::prompt(_("Unapplied changes"),
1873 _("Some changes in the dialog were not yet applied.\n"
1874 "If you do not apply now, they will be lost after this action."),
1875 1, 1, _("&Apply"), _("&Dismiss"));
1881 // We load the TextClass as soon as it is selected. This is
1882 // necessary so that other options in the dialog can be updated
1883 // according to the new class. Note, however, that, if you use
1884 // the scroll wheel when sitting on the combo box, we'll load a
1885 // lot of TextClass objects very quickly....
1886 if (!bp_.setBaseClass(classname)) {
1887 Alert::error(_("Error"), _("Unable to set document class."));
1890 if (lyxrc.auto_reset_options)
1891 bp_.useClassDefaults();
1893 // With the introduction of modules came a distinction between the base
1894 // class and the document class. The former corresponds to the main layout
1895 // file; the latter is that plus the modules (or the document-specific layout,
1896 // or whatever else there could be). Our parameters come from the document
1897 // class. So when we set the base class, we also need to recreate the document
1898 // class. Otherwise, we still have the old one.
1899 bp_.makeDocumentClass();
1904 void GuiDocument::languagePackageChanged(int i)
1906 langModule->languagePackageED->setEnabled(
1907 langModule->languagePackageCO->itemData(i).toString() == "custom");
1911 void GuiDocument::bibtexChanged(int n)
1913 biblioModule->bibtexOptionsED->setEnabled(
1914 biblioModule->bibtexCO->itemData(n).toString() != "default");
1921 // both of these should take a vector<docstring>
1923 // This is an insanely complicated attempt to make this sort of thing
1924 // work with RTL languages.
1925 docstring formatStrVec(vector<string> const & v, docstring const & s)
1927 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1931 return translateIfPossible(from_utf8(v[0]));
1932 if (v.size() == 2) {
1933 docstring retval = _("%1$s and %2$s");
1934 retval = subst(retval, _("and"), s);
1935 return bformat(retval, translateIfPossible(from_utf8(v[0])),
1936 translateIfPossible(from_utf8(v[1])));
1938 // The idea here is to format all but the last two items...
1939 int const vSize = v.size();
1940 docstring t2 = _("%1$s, %2$s");
1941 docstring retval = translateIfPossible(from_utf8(v[0]));
1942 for (int i = 1; i < vSize - 2; ++i)
1943 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
1944 //...and then to plug them, and the last two, into this schema
1945 docstring t = _("%1$s, %2$s, and %3$s");
1946 t = subst(t, _("and"), s);
1947 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
1948 translateIfPossible(from_utf8(v[vSize - 1])));
1951 vector<string> idsToNames(vector<string> const & idList)
1953 vector<string> retval;
1954 vector<string>::const_iterator it = idList.begin();
1955 vector<string>::const_iterator end = idList.end();
1956 for (; it != end; ++it) {
1957 LyXModule const * const mod = theModuleList[*it];
1959 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
1960 translateIfPossible(from_utf8(*it)))));
1962 retval.push_back(mod->getName());
1966 } // end anonymous namespace
1969 void GuiDocument::modulesToParams(BufferParams & bp)
1971 // update list of loaded modules
1972 bp.clearLayoutModules();
1973 int const srows = modules_sel_model_.rowCount();
1974 for (int i = 0; i < srows; ++i)
1975 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1977 // update the list of removed modules
1978 bp.clearRemovedModules();
1979 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1980 list<string>::const_iterator rit = reqmods.begin();
1981 list<string>::const_iterator ren = reqmods.end();
1983 // check each of the default modules
1984 for (; rit != ren; rit++) {
1985 list<string>::const_iterator mit = bp.getModules().begin();
1986 list<string>::const_iterator men = bp.getModules().end();
1988 for (; mit != men; mit++) {
1995 // the module isn't present so must have been removed by the user
1996 bp.addRemovedModule(*rit);
2001 void GuiDocument::modulesChanged()
2003 modulesToParams(bp_);
2004 bp_.makeDocumentClass();
2009 void GuiDocument::updateModuleInfo()
2011 selectionManager->update();
2013 //Module description
2014 bool const focus_on_selected = selectionManager->selectedFocused();
2015 QAbstractItemView * lv;
2016 if (focus_on_selected)
2017 lv = modulesModule->selectedLV;
2019 lv= modulesModule->availableLV;
2020 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2021 modulesModule->infoML->document()->clear();
2024 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2025 GuiIdListModel const & id_model =
2026 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2027 string const modName = id_model.getIDString(idx.row());
2028 docstring desc = getModuleDescription(modName);
2030 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2031 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2034 desc += _("Module provided by document class.");
2037 vector<string> pkglist = getPackageList(modName);
2038 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2039 if (!pkgdesc.empty()) {
2042 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2045 pkglist = getRequiredList(modName);
2046 if (!pkglist.empty()) {
2047 vector<string> const reqdescs = idsToNames(pkglist);
2048 pkgdesc = formatStrVec(reqdescs, _("or"));
2051 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2054 pkglist = getExcludedList(modName);
2055 if (!pkglist.empty()) {
2056 vector<string> const reqdescs = idsToNames(pkglist);
2057 pkgdesc = formatStrVec(reqdescs, _( "and"));
2060 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2063 if (!isModuleAvailable(modName)) {
2066 desc += _("WARNING: Some required packages are unavailable!");
2069 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2073 void GuiDocument::updateNumbering()
2075 DocumentClass const & tclass = documentClass();
2077 numberingModule->tocTW->setUpdatesEnabled(false);
2078 numberingModule->tocTW->clear();
2080 int const depth = numberingModule->depthSL->value();
2081 int const toc = numberingModule->tocSL->value();
2082 QString const no = qt_("No");
2083 QString const yes = qt_("Yes");
2084 QTreeWidgetItem * item = 0;
2086 DocumentClass::const_iterator lit = tclass.begin();
2087 DocumentClass::const_iterator len = tclass.end();
2088 for (; lit != len; ++lit) {
2089 int const toclevel = lit->toclevel;
2090 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2091 item = new QTreeWidgetItem(numberingModule->tocTW);
2092 item->setText(0, toqstr(translateIfPossible(lit->name())));
2093 item->setText(1, (toclevel <= depth) ? yes : no);
2094 item->setText(2, (toclevel <= toc) ? yes : no);
2098 numberingModule->tocTW->setUpdatesEnabled(true);
2099 numberingModule->tocTW->update();
2103 void GuiDocument::updateDefaultFormat()
2107 // make a copy in order to consider unapplied changes
2108 Buffer * tmpbuf = buffer().clone();
2109 tmpbuf->params().useNonTeXFonts =
2110 fontModule->osFontsCB->isChecked();
2111 int idx = latexModule->classCO->currentIndex();
2113 string const classname = classes_model_.getIDString(idx);
2114 tmpbuf->params().setBaseClass(classname);
2115 tmpbuf->params().makeDocumentClass();
2117 outputModule->defaultFormatCO->blockSignals(true);
2118 outputModule->defaultFormatCO->clear();
2119 outputModule->defaultFormatCO->addItem(qt_("Default"),
2120 QVariant(QString("default")));
2121 typedef vector<Format const *> Formats;
2122 Formats formats = tmpbuf->exportableFormats(true);
2123 Formats::const_iterator cit = formats.begin();
2124 Formats::const_iterator end = formats.end();
2125 for (; cit != end; ++cit)
2126 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2127 QVariant(toqstr((*cit)->name())));
2128 outputModule->defaultFormatCO->blockSignals(false);
2134 bool GuiDocument::isChildIncluded(string const & child)
2136 if (includeonlys_.empty())
2138 return (std::find(includeonlys_.begin(),
2139 includeonlys_.end(), child) != includeonlys_.end());
2143 void GuiDocument::applyView()
2146 preambleModule->apply(bp_);
2147 localLayout->apply(bp_);
2150 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2151 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2154 bp_.setCiteEngine(ENGINE_BASIC);
2156 if (biblioModule->citeNatbibRB->isChecked()) {
2157 bool const use_numerical_citations =
2158 biblioModule->citeStyleCO->currentIndex();
2159 if (use_numerical_citations)
2160 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2162 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2164 } else if (biblioModule->citeJurabibRB->isChecked())
2165 bp_.setCiteEngine(ENGINE_JURABIB);
2168 biblioModule->bibtopicCB->isChecked();
2170 string const bibtex_command =
2171 fromqstr(biblioModule->bibtexCO->itemData(
2172 biblioModule->bibtexCO->currentIndex()).toString());
2173 string const bibtex_options =
2174 fromqstr(biblioModule->bibtexOptionsED->text());
2175 if (bibtex_command == "default" || bibtex_options.empty())
2176 bp_.bibtex_command = bibtex_command;
2178 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2181 indicesModule->apply(bp_);
2183 // language & quotes
2184 if (langModule->defaultencodingRB->isChecked()) {
2185 bp_.inputenc = "auto";
2187 int i = langModule->encodingCO->currentIndex();
2189 bp_.inputenc = "default";
2191 QString const enc_gui =
2192 langModule->encodingCO->currentText();
2193 Encodings::const_iterator it = encodings.begin();
2194 Encodings::const_iterator const end = encodings.end();
2196 for (; it != end; ++it) {
2197 if (qt_(it->guiName()) == enc_gui) {
2198 bp_.inputenc = it->latexName();
2204 // should not happen
2205 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2206 bp_.inputenc = "default";
2211 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2212 switch (langModule->quoteStyleCO->currentIndex()) {
2214 lga = InsetQuotes::EnglishQuotes;
2217 lga = InsetQuotes::SwedishQuotes;
2220 lga = InsetQuotes::GermanQuotes;
2223 lga = InsetQuotes::PolishQuotes;
2226 lga = InsetQuotes::FrenchQuotes;
2229 lga = InsetQuotes::DanishQuotes;
2232 bp_.quotes_language = lga;
2234 QString const lang = langModule->languageCO->itemData(
2235 langModule->languageCO->currentIndex()).toString();
2236 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2238 QString const pack = langModule->languagePackageCO->itemData(
2239 langModule->languagePackageCO->currentIndex()).toString();
2240 if (pack == "custom")
2242 fromqstr(langModule->languagePackageED->text());
2244 bp_.lang_package = fromqstr(pack);
2247 bp_.backgroundcolor = set_backgroundcolor;
2248 bp_.isbackgroundcolor = is_backgroundcolor;
2249 bp_.fontcolor = set_fontcolor;
2250 bp_.isfontcolor = is_fontcolor;
2251 bp_.notefontcolor = set_notefontcolor;
2252 bp_.boxbgcolor = set_boxbgcolor;
2255 if (bp_.documentClass().hasTocLevels()) {
2256 bp_.tocdepth = numberingModule->tocSL->value();
2257 bp_.secnumdepth = numberingModule->depthSL->value();
2261 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2262 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2263 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2264 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2267 bp_.graphics_driver =
2268 tex_graphics[latexModule->psdriverCO->currentIndex()];
2271 int idx = latexModule->classCO->currentIndex();
2273 string const classname = classes_model_.getIDString(idx);
2274 bp_.setBaseClass(classname);
2278 modulesToParams(bp_);
2281 if (mathsModule->amsautoCB->isChecked())
2282 bp_.use_amsmath = BufferParams::package_auto;
2284 if (mathsModule->amsCB->isChecked())
2285 bp_.use_amsmath = BufferParams::package_on;
2287 bp_.use_amsmath = BufferParams::package_off;
2289 if (mathsModule->esintautoCB->isChecked())
2290 bp_.use_esint = BufferParams::package_auto;
2292 if (mathsModule->esintCB->isChecked())
2293 bp_.use_esint = BufferParams::package_on;
2295 bp_.use_esint = BufferParams::package_off;
2297 if (mathsModule->mhchemautoCB->isChecked())
2298 bp_.use_mhchem = BufferParams::package_auto;
2300 if (mathsModule->mhchemCB->isChecked())
2301 bp_.use_mhchem = BufferParams::package_on;
2303 bp_.use_mhchem = BufferParams::package_off;
2305 if (mathsModule->mathdotsautoCB->isChecked())
2306 bp_.use_mathdots = BufferParams::package_auto;
2308 if (mathsModule->mathdotsCB->isChecked())
2309 bp_.use_mathdots = BufferParams::package_on;
2311 bp_.use_mathdots = BufferParams::package_off;
2315 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2316 bp_.pagestyle = "default";
2318 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2319 for (size_t i = 0; i != pagestyles.size(); ++i)
2320 if (pagestyles[i].second == style_gui)
2321 bp_.pagestyle = pagestyles[i].first;
2325 switch (textLayoutModule->lspacingCO->currentIndex()) {
2327 bp_.spacing().set(Spacing::Single);
2330 bp_.spacing().set(Spacing::Onehalf);
2333 bp_.spacing().set(Spacing::Double);
2336 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2338 bp_.spacing().set(Spacing::Single);
2340 bp_.spacing().set(Spacing::Other, s);
2345 if (textLayoutModule->twoColumnCB->isChecked())
2350 if (textLayoutModule->indentRB->isChecked()) {
2351 // if paragraphs are separated by an indentation
2352 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2353 switch (textLayoutModule->indentCO->currentIndex()) {
2355 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2358 HSpace indent = HSpace(
2359 widgetsToLength(textLayoutModule->indentLE,
2360 textLayoutModule->indentLengthCO)
2362 bp_.setIndentation(indent);
2366 // this should never happen
2367 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2371 // if paragraphs are separated by a skip
2372 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2373 switch (textLayoutModule->skipCO->currentIndex()) {
2375 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2378 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2381 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2386 widgetsToLength(textLayoutModule->skipLE,
2387 textLayoutModule->skipLengthCO)
2393 // this should never happen
2394 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2400 fromqstr(latexModule->optionsLE->text());
2402 bp_.use_default_options =
2403 latexModule->defaultOptionsCB->isChecked();
2405 if (latexModule->childDocGB->isChecked())
2407 fromqstr(latexModule->childDocLE->text());
2409 bp_.master = string();
2412 bp_.clearIncludedChildren();
2413 if (masterChildModule->includeonlyRB->isChecked()) {
2414 list<string>::const_iterator it = includeonlys_.begin();
2415 for (; it != includeonlys_.end() ; ++it) {
2416 bp_.addIncludedChildren(*it);
2419 bp_.maintain_unincluded_children =
2420 masterChildModule->maintainAuxCB->isChecked();
2423 bp_.float_placement = floatModule->get();
2426 // text should have passed validation
2427 bp_.listings_params =
2428 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2431 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2432 outputModule->defaultFormatCO->currentIndex()).toString());
2434 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2435 bp_.useNonTeXFonts = nontexfonts;
2437 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2438 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2440 int mathfmt = outputModule->mathoutCB->currentIndex();
2443 BufferParams::MathOutput const mo =
2444 static_cast<BufferParams::MathOutput>(mathfmt);
2445 bp_.html_math_output = mo;
2446 bp_.html_be_strict = outputModule->strictCB->isChecked();
2447 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2451 fromqstr(fontModule->fontsRomanCO->
2452 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2455 fromqstr(fontModule->fontsSansCO->
2456 itemData(fontModule->fontsSansCO->currentIndex()).toString());
2458 bp_.fonts_typewriter =
2459 fromqstr(fontModule->fontsTypewriterCO->
2460 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2462 if (fontModule->fontencCO->currentIndex() == 0)
2463 bp_.fontenc = "global";
2464 else if (fontModule->fontencCO->currentIndex() == 1)
2465 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2466 else if (fontModule->fontencCO->currentIndex() == 2)
2467 bp_.fontenc = "default";
2470 fromqstr(fontModule->cjkFontLE->text());
2472 bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2474 bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2476 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2478 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2481 bp_.fonts_default_family = "default";
2483 bp_.fonts_default_family = GuiDocument::fontfamilies[
2484 fontModule->fontsDefaultCO->currentIndex()];
2486 if (fontModule->fontsizeCO->currentIndex() == 0)
2487 bp_.fontsize = "default";
2490 fromqstr(fontModule->fontsizeCO->currentText());
2493 bp_.papersize = PAPER_SIZE(
2494 pageLayoutModule->papersizeCO->currentIndex());
2496 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2497 pageLayoutModule->paperwidthUnitCO);
2499 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2500 pageLayoutModule->paperheightUnitCO);
2502 if (pageLayoutModule->facingPagesCB->isChecked())
2503 bp_.sides = TwoSides;
2505 bp_.sides = OneSide;
2507 if (pageLayoutModule->landscapeRB->isChecked())
2508 bp_.orientation = ORIENTATION_LANDSCAPE;
2510 bp_.orientation = ORIENTATION_PORTRAIT;
2513 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2515 Ui::MarginsUi const * m = marginsModule;
2517 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2518 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2519 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2520 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2521 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2522 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2523 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2524 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2527 branchesModule->apply(bp_);
2530 PDFOptions & pdf = bp_.pdfoptions();
2531 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2532 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2533 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2534 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2535 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2537 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2538 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2539 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2540 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2542 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2543 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2544 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2545 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2547 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2548 if (pdfSupportModule->fullscreenCB->isChecked())
2549 pdf.pagemode = pdf.pagemode_fullscreen;
2551 pdf.pagemode.clear();
2552 pdf.quoted_options = pdf.quoted_options_check(
2553 fromqstr(pdfSupportModule->optionsLE->text()));
2557 void GuiDocument::paramsToDialog()
2559 // set the default unit
2560 Length::UNIT const defaultUnit = Length::defaultUnit();
2563 preambleModule->update(bp_, id());
2564 localLayout->update(bp_, id());
2567 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2568 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2571 biblioModule->citeDefaultRB->setChecked(
2572 bp_.citeEngine() == ENGINE_BASIC);
2574 biblioModule->citeNatbibRB->setChecked(
2575 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2576 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2578 biblioModule->citeStyleCO->setCurrentIndex(
2579 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2581 biblioModule->citeJurabibRB->setChecked(
2582 bp_.citeEngine() == ENGINE_JURABIB);
2584 biblioModule->bibtopicCB->setChecked(
2589 split(bp_.bibtex_command, command, ' ');
2591 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2593 biblioModule->bibtexCO->setCurrentIndex(bpos);
2594 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2596 // We reset to default if we do not know the specified compiler
2597 // This is for security reasons
2598 biblioModule->bibtexCO->setCurrentIndex(
2599 biblioModule->bibtexCO->findData(toqstr("default")));
2600 biblioModule->bibtexOptionsED->clear();
2602 biblioModule->bibtexOptionsED->setEnabled(
2603 biblioModule->bibtexCO->currentIndex() != 0);
2606 indicesModule->update(bp_);
2608 // language & quotes
2609 int const pos = langModule->languageCO->findData(toqstr(
2610 bp_.language->lang()));
2611 langModule->languageCO->setCurrentIndex(pos);
2613 langModule->quoteStyleCO->setCurrentIndex(
2614 bp_.quotes_language);
2616 bool default_enc = true;
2617 if (bp_.inputenc != "auto") {
2618 default_enc = false;
2619 if (bp_.inputenc == "default") {
2620 langModule->encodingCO->setCurrentIndex(0);
2623 Encodings::const_iterator it = encodings.begin();
2624 Encodings::const_iterator const end = encodings.end();
2625 for (; it != end; ++it) {
2626 if (it->latexName() == bp_.inputenc) {
2627 enc_gui = it->guiName();
2631 int const i = langModule->encodingCO->findText(
2634 langModule->encodingCO->setCurrentIndex(i);
2636 // unknown encoding. Set to default.
2640 langModule->defaultencodingRB->setChecked(default_enc);
2641 langModule->otherencodingRB->setChecked(!default_enc);
2643 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2645 langModule->languagePackageCO->setCurrentIndex(
2646 langModule->languagePackageCO->findData("custom"));
2647 langModule->languagePackageED->setText(toqstr(bp_.lang_package));
2649 langModule->languagePackageCO->setCurrentIndex(p);
2650 langModule->languagePackageED->clear();
2654 if (bp_.isfontcolor) {
2655 colorModule->fontColorPB->setStyleSheet(
2656 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2658 set_fontcolor = bp_.fontcolor;
2659 is_fontcolor = bp_.isfontcolor;
2661 colorModule->noteFontColorPB->setStyleSheet(
2662 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2663 set_notefontcolor = bp_.notefontcolor;
2665 if (bp_.isbackgroundcolor) {
2666 colorModule->backgroundPB->setStyleSheet(
2667 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2669 set_backgroundcolor = bp_.backgroundcolor;
2670 is_backgroundcolor = bp_.isbackgroundcolor;
2672 colorModule->boxBackgroundPB->setStyleSheet(
2673 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2674 set_boxbgcolor = bp_.boxbgcolor;
2677 int const min_toclevel = documentClass().min_toclevel();
2678 int const max_toclevel = documentClass().max_toclevel();
2679 if (documentClass().hasTocLevels()) {
2680 numberingModule->setEnabled(true);
2681 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2682 numberingModule->depthSL->setMaximum(max_toclevel);
2683 numberingModule->depthSL->setValue(bp_.secnumdepth);
2684 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2685 numberingModule->tocSL->setMaximum(max_toclevel);
2686 numberingModule->tocSL->setValue(bp_.tocdepth);
2689 numberingModule->setEnabled(false);
2690 numberingModule->tocTW->clear();
2694 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2695 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2696 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2697 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2698 bulletsModule->init();
2701 int nitem = findToken(tex_graphics, bp_.graphics_driver);
2703 latexModule->psdriverCO->setCurrentIndex(nitem);
2706 mathsModule->amsCB->setChecked(
2707 bp_.use_amsmath == BufferParams::package_on);
2708 mathsModule->amsautoCB->setChecked(
2709 bp_.use_amsmath == BufferParams::package_auto);
2711 mathsModule->esintCB->setChecked(
2712 bp_.use_esint == BufferParams::package_on);
2713 mathsModule->esintautoCB->setChecked(
2714 bp_.use_esint == BufferParams::package_auto);
2716 mathsModule->mhchemCB->setChecked(
2717 bp_.use_mhchem == BufferParams::package_on);
2718 mathsModule->mhchemautoCB->setChecked(
2719 bp_.use_mhchem == BufferParams::package_auto);
2721 mathsModule->mathdotsCB->setChecked(
2722 bp_.use_mathdots == BufferParams::package_on);
2723 mathsModule->mathdotsautoCB->setChecked(
2724 bp_.use_mathdots == BufferParams::package_auto);
2726 switch (bp_.spacing().getSpace()) {
2727 case Spacing::Other: nitem = 3; break;
2728 case Spacing::Double: nitem = 2; break;
2729 case Spacing::Onehalf: nitem = 1; break;
2730 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2734 string const & layoutID = bp_.baseClassID();
2735 setLayoutComboByIDString(layoutID);
2737 updatePagestyle(documentClass().opt_pagestyle(),
2740 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2741 if (bp_.spacing().getSpace() == Spacing::Other) {
2742 doubleToWidget(textLayoutModule->lspacingLE,
2743 bp_.spacing().getValueAsString());
2747 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2748 textLayoutModule->indentRB->setChecked(true);
2749 string indentation = bp_.getIndentation().asLyXCommand();
2751 if (indentation != "default") {
2752 lengthToWidgets(textLayoutModule->indentLE,
2753 textLayoutModule->indentLengthCO,
2754 indentation, defaultUnit);
2757 textLayoutModule->indentCO->setCurrentIndex(indent);
2760 textLayoutModule->skipRB->setChecked(true);
2762 switch (bp_.getDefSkip().kind()) {
2763 case VSpace::SMALLSKIP:
2766 case VSpace::MEDSKIP:
2769 case VSpace::BIGSKIP:
2772 case VSpace::LENGTH:
2775 string const length = bp_.getDefSkip().asLyXCommand();
2776 lengthToWidgets(textLayoutModule->skipLE,
2777 textLayoutModule->skipLengthCO,
2778 length, defaultUnit);
2785 textLayoutModule->skipCO->setCurrentIndex(skip);
2789 textLayoutModule->twoColumnCB->setChecked(
2792 if (!bp_.options.empty()) {
2793 latexModule->optionsLE->setText(
2794 toqstr(bp_.options));
2796 latexModule->optionsLE->setText(QString());
2800 latexModule->defaultOptionsCB->setChecked(
2801 bp_.use_default_options);
2802 updateSelectedModules();
2803 selectionManager->updateProvidedModules(
2804 bp_.baseClass()->providedModules());
2805 selectionManager->updateExcludedModules(
2806 bp_.baseClass()->excludedModules());
2808 if (!documentClass().options().empty()) {
2809 latexModule->defaultOptionsLE->setText(
2810 toqstr(documentClass().options()));
2812 latexModule->defaultOptionsLE->setText(
2813 toqstr(_("[No options predefined]")));
2816 latexModule->defaultOptionsLE->setEnabled(
2817 bp_.use_default_options
2818 && !documentClass().options().empty());
2820 latexModule->defaultOptionsCB->setEnabled(
2821 !documentClass().options().empty());
2823 if (!bp_.master.empty()) {
2824 latexModule->childDocGB->setChecked(true);
2825 latexModule->childDocLE->setText(
2826 toqstr(bp_.master));
2828 latexModule->childDocLE->setText(QString());
2829 latexModule->childDocGB->setChecked(false);
2833 if (!bufferview() || !buffer().hasChildren()) {
2834 masterChildModule->childrenTW->clear();
2835 includeonlys_.clear();
2836 docPS->showPanel(qt_("Child Documents"), false);
2837 if (docPS->isCurrentPanel(qt_("Child Documents")))
2838 docPS->setCurrentPanel(qt_("Document Class"));
2840 docPS->showPanel(qt_("Child Documents"), true);
2841 masterChildModule->setEnabled(true);
2842 includeonlys_ = bp_.getIncludedChildren();
2843 updateIncludeonlys();
2845 masterChildModule->maintainAuxCB->setChecked(
2846 bp_.maintain_unincluded_children);
2849 floatModule->set(bp_.float_placement);
2852 // break listings_params to multiple lines
2854 InsetListingsParams(bp_.listings_params).separatedParams();
2855 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2858 // update combobox with formats
2859 updateDefaultFormat();
2860 int index = outputModule->defaultFormatCO->findData(toqstr(
2861 bp_.default_output_format));
2862 // set to default if format is not found
2865 outputModule->defaultFormatCO->setCurrentIndex(index);
2866 bool const os_fonts_available =
2867 bp_.baseClass()->outputType() == lyx::LATEX
2868 && LaTeXFeatures::isAvailable("fontspec");
2869 fontModule->osFontsCB->setEnabled(os_fonts_available);
2870 fontModule->osFontsCB->setChecked(
2871 os_fonts_available && bp_.useNonTeXFonts);
2873 outputModule->outputsyncCB->setChecked(bp_.output_sync);
2874 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2876 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2877 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2878 outputModule->strictCB->setChecked(bp_.html_be_strict);
2881 updateFontsize(documentClass().opt_fontsize(),
2884 QString font = toqstr(bp_.fonts_roman);
2885 int rpos = fontModule->fontsRomanCO->findData(font);
2887 rpos = fontModule->fontsRomanCO->count();
2888 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
2890 fontModule->fontsRomanCO->setCurrentIndex(rpos);
2892 font = toqstr(bp_.fonts_sans);
2893 int spos = fontModule->fontsSansCO->findData(font);
2895 spos = fontModule->fontsSansCO->count();
2896 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
2898 fontModule->fontsSansCO->setCurrentIndex(spos);
2900 font = toqstr(bp_.fonts_typewriter);
2901 int tpos = fontModule->fontsTypewriterCO->findData(font);
2903 tpos = fontModule->fontsTypewriterCO->count();
2904 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
2906 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
2908 if (bp_.useNonTeXFonts && os_fonts_available) {
2909 fontModule->fontencLA->setEnabled(false);
2910 fontModule->fontencCO->setEnabled(false);
2911 fontModule->fontencLE->setEnabled(false);
2913 fontModule->fontencLA->setEnabled(true);
2914 fontModule->fontencCO->setEnabled(true);
2915 fontModule->fontencLE->setEnabled(true);
2921 if (!bp_.fonts_cjk.empty())
2922 fontModule->cjkFontLE->setText(
2923 toqstr(bp_.fonts_cjk));
2925 fontModule->cjkFontLE->setText(QString());
2927 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
2928 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
2929 fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
2930 fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
2932 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
2934 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2936 if (bp_.fontenc == "global") {
2937 fontModule->fontencCO->setCurrentIndex(0);
2938 fontModule->fontencLE->setEnabled(false);
2939 } else if (bp_.fontenc == "default") {
2940 fontModule->fontencCO->setCurrentIndex(2);
2941 fontModule->fontencLE->setEnabled(false);
2943 fontModule->fontencCO->setCurrentIndex(1);
2944 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2948 bool const extern_geometry =
2949 documentClass().provides("geometry");
2950 int const psize = bp_.papersize;
2951 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2952 setCustomPapersize(!extern_geometry && psize == 1);
2953 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2955 bool const landscape =
2956 bp_.orientation == ORIENTATION_LANDSCAPE;
2957 pageLayoutModule->landscapeRB->setChecked(landscape);
2958 pageLayoutModule->portraitRB->setChecked(!landscape);
2959 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2960 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2962 pageLayoutModule->facingPagesCB->setChecked(
2963 bp_.sides == TwoSides);
2965 lengthToWidgets(pageLayoutModule->paperwidthLE,
2966 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2967 lengthToWidgets(pageLayoutModule->paperheightLE,
2968 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2971 Ui::MarginsUi * m = marginsModule;
2975 lengthToWidgets(m->topLE, m->topUnit,
2976 bp_.topmargin, defaultUnit);
2978 lengthToWidgets(m->bottomLE, m->bottomUnit,
2979 bp_.bottommargin, defaultUnit);
2981 lengthToWidgets(m->innerLE, m->innerUnit,
2982 bp_.leftmargin, defaultUnit);
2984 lengthToWidgets(m->outerLE, m->outerUnit,
2985 bp_.rightmargin, defaultUnit);
2987 lengthToWidgets(m->headheightLE, m->headheightUnit,
2988 bp_.headheight, defaultUnit);
2990 lengthToWidgets(m->headsepLE, m->headsepUnit,
2991 bp_.headsep, defaultUnit);
2993 lengthToWidgets(m->footskipLE, m->footskipUnit,
2994 bp_.footskip, defaultUnit);
2996 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2997 bp_.columnsep, defaultUnit);
3000 updateUnknownBranches();
3001 branchesModule->update(bp_);
3004 PDFOptions const & pdf = bp_.pdfoptions();
3005 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3006 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3007 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3008 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3009 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3011 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3012 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3013 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3015 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3017 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3018 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3019 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3020 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3022 nn = findToken(backref_opts, pdf.backref);
3024 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3026 pdfSupportModule->fullscreenCB->setChecked
3027 (pdf.pagemode == pdf.pagemode_fullscreen);
3029 pdfSupportModule->optionsLE->setText(
3030 toqstr(pdf.quoted_options));
3032 // Make sure that the bc is in the INITIAL state
3033 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3036 // clear changed branches cache
3037 changedBranches_.clear();
3041 void GuiDocument::saveDocDefault()
3043 // we have to apply the params first
3049 void GuiDocument::updateAvailableModules()
3051 modules_av_model_.clear();
3052 list<modInfoStruct> const & modInfoList = getModuleInfo();
3053 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3054 list<modInfoStruct>::const_iterator men = modInfoList.end();
3055 for (int i = 0; mit != men; ++mit, ++i)
3056 modules_av_model_.insertRow(i, mit->name, mit->id,
3061 void GuiDocument::updateSelectedModules()
3063 modules_sel_model_.clear();
3064 list<modInfoStruct> const selModList = getSelectedModules();
3065 list<modInfoStruct>::const_iterator mit = selModList.begin();
3066 list<modInfoStruct>::const_iterator men = selModList.end();
3067 for (int i = 0; mit != men; ++mit, ++i)
3068 modules_sel_model_.insertRow(i, mit->name, mit->id,
3073 void GuiDocument::updateIncludeonlys()
3075 masterChildModule->childrenTW->clear();
3076 QString const no = qt_("No");
3077 QString const yes = qt_("Yes");
3079 if (includeonlys_.empty()) {
3080 masterChildModule->includeallRB->setChecked(true);
3081 masterChildModule->childrenTW->setEnabled(false);
3082 masterChildModule->maintainAuxCB->setEnabled(false);
3084 masterChildModule->includeonlyRB->setChecked(true);
3085 masterChildModule->childrenTW->setEnabled(true);
3086 masterChildModule->maintainAuxCB->setEnabled(true);
3088 QTreeWidgetItem * item = 0;
3089 ListOfBuffers children = buffer().getChildren();
3090 ListOfBuffers::const_iterator it = children.begin();
3091 ListOfBuffers::const_iterator end = children.end();
3092 bool has_unincluded = false;
3093 bool all_unincluded = true;
3094 for (; it != end; ++it) {
3095 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3098 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3099 from_utf8(buffer().filePath())));
3100 item->setText(0, toqstr(name));
3101 item->setText(1, isChildIncluded(name) ? yes : no);
3102 if (!isChildIncluded(name))
3103 has_unincluded = true;
3105 all_unincluded = false;
3107 // Both if all childs are included and if none is included
3108 // is equal to "include all" (i.e., ommit \includeonly).
3109 // Thus, reset the GUI.
3110 if (!has_unincluded || all_unincluded) {
3111 masterChildModule->includeallRB->setChecked(true);
3112 masterChildModule->childrenTW->setEnabled(false);
3113 includeonlys_.clear();
3115 // If all are included, we need to update again.
3116 if (!has_unincluded)
3117 updateIncludeonlys();
3121 void GuiDocument::updateContents()
3123 // Nothing to do here as the document settings is not cursor dependant.
3128 void GuiDocument::useClassDefaults()
3130 if (applyPB->isEnabled()) {
3131 int const ret = Alert::prompt(_("Unapplied changes"),
3132 _("Some changes in the dialog were not yet applied.\n"
3133 "If you do not apply now, they will be lost after this action."),
3134 1, 1, _("&Apply"), _("&Dismiss"));
3139 int idx = latexModule->classCO->currentIndex();
3140 string const classname = classes_model_.getIDString(idx);
3141 if (!bp_.setBaseClass(classname)) {
3142 Alert::error(_("Error"), _("Unable to set document class."));
3145 bp_.useClassDefaults();
3150 void GuiDocument::setLayoutComboByIDString(string const & idString)
3152 int idx = classes_model_.findIDString(idString);
3154 Alert::warning(_("Can't set layout!"),
3155 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3157 latexModule->classCO->setCurrentIndex(idx);
3161 bool GuiDocument::isValid()
3164 validateListingsParameters().isEmpty() &&
3165 localLayout->isValid() &&
3167 // if we're asking for skips between paragraphs
3168 !textLayoutModule->skipRB->isChecked() ||
3169 // then either we haven't chosen custom
3170 textLayoutModule->skipCO->currentIndex() != 3 ||
3171 // or else a length has been given
3172 !textLayoutModule->skipLE->text().isEmpty()
3175 // if we're asking for indentation
3176 !textLayoutModule->indentRB->isChecked() ||
3177 // then either we haven't chosen custom
3178 textLayoutModule->indentCO->currentIndex() != 1 ||
3179 // or else a length has been given
3180 !textLayoutModule->indentLE->text().isEmpty()
3185 char const * const GuiDocument::fontfamilies[5] = {
3186 "default", "rmdefault", "sfdefault", "ttdefault", ""
3190 char const * GuiDocument::fontfamilies_gui[5] = {
3191 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3195 bool GuiDocument::initialiseParams(string const &)
3197 BufferView const * view = bufferview();
3199 bp_ = BufferParams();
3203 bp_ = view->buffer().params();
3205 updateAvailableModules();
3206 //FIXME It'd be nice to make sure here that the selected
3207 //modules are consistent: That required modules are actually
3208 //selected, and that we don't have conflicts. If so, we could
3209 //at least pop up a warning.
3215 void GuiDocument::clearParams()
3217 bp_ = BufferParams();
3221 BufferId GuiDocument::id() const
3223 BufferView const * const view = bufferview();
3224 return view? &view->buffer() : 0;
3228 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3230 return moduleNames_;
3234 list<GuiDocument::modInfoStruct> const
3235 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3237 LayoutModuleList::const_iterator it = mods.begin();
3238 LayoutModuleList::const_iterator end = mods.end();
3239 list<modInfoStruct> mInfo;
3240 for (; it != end; ++it) {
3243 LyXModule const * const mod = theModuleList[*it];
3246 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3248 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3255 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3257 return makeModuleInfo(params().getModules());
3261 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3263 return makeModuleInfo(params().baseClass()->providedModules());
3267 DocumentClass const & GuiDocument::documentClass() const
3269 return bp_.documentClass();
3273 static void dispatch_bufferparams(Dialog const & dialog,
3274 BufferParams const & bp, FuncCode lfun)
3277 ss << "\\begin_header\n";
3279 ss << "\\end_header\n";
3280 dialog.dispatch(FuncRequest(lfun, ss.str()));
3284 void GuiDocument::dispatchParams()
3286 // This must come first so that a language change is correctly noticed
3289 // Apply the BufferParams. Note that this will set the base class
3290 // and then update the buffer's layout.
3291 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3293 if (!params().master.empty()) {
3294 FileName const master_file = support::makeAbsPath(params().master,
3295 support::onlyPath(buffer().absFileName()));
3296 if (isLyXFileName(master_file.absFileName())) {
3297 Buffer * master = checkAndLoadLyXFile(master_file);
3299 if (master->isChild(const_cast<Buffer *>(&buffer())))
3300 const_cast<Buffer &>(buffer()).setParent(master);
3302 Alert::warning(_("Assigned master does not include this file"),
3303 bformat(_("You must include this file in the document\n"
3304 "'%1$s' in order to use the master document\n"
3305 "feature."), from_utf8(params().master)));
3307 Alert::warning(_("Could not load master"),
3308 bformat(_("The master document '%1$s'\n"
3309 "could not be loaded."),
3310 from_utf8(params().master)));
3314 // Generate the colours requested by each new branch.
3315 BranchList & branchlist = params().branchlist();
3316 if (!branchlist.empty()) {
3317 BranchList::const_iterator it = branchlist.begin();
3318 BranchList::const_iterator const end = branchlist.end();
3319 for (; it != end; ++it) {
3320 docstring const & current_branch = it->branch();
3321 Branch const * branch = branchlist.find(current_branch);
3322 string const x11hexname = X11hexname(branch->color());
3323 // display the new color
3324 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3325 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3328 // Open insets of selected branches, close deselected ones
3329 dispatch(FuncRequest(LFUN_INSET_FORALL,
3330 "Branch inset-toggle assign"));
3332 // rename branches in the document
3333 executeBranchRenaming();
3334 // and clear changed branches cache
3335 changedBranches_.clear();
3337 // Generate the colours requested by indices.
3338 IndicesList & indiceslist = params().indiceslist();
3339 if (!indiceslist.empty()) {
3340 IndicesList::const_iterator it = indiceslist.begin();
3341 IndicesList::const_iterator const end = indiceslist.end();
3342 for (; it != end; ++it) {
3343 docstring const & current_index = it->shortcut();
3344 Index const * index = indiceslist.findShortcut(current_index);
3345 string const x11hexname = X11hexname(index->color());
3346 // display the new color
3347 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3348 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3352 // If we used an LFUN, we would not need these two lines:
3353 BufferView * bv = const_cast<BufferView *>(bufferview());
3354 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3358 void GuiDocument::setLanguage() const
3360 Language const * const newL = bp_.language;
3361 if (buffer().params().language == newL)
3364 string const & lang_name = newL->lang();
3365 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3369 void GuiDocument::saveAsDefault() const
3371 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3375 bool GuiDocument::isFontAvailable(string const & font) const
3377 if (font == "default" || font == "cmr"
3378 || font == "cmss" || font == "cmtt")
3379 // these are standard
3381 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3382 return LaTeXFeatures::isAvailable("lmodern");
3383 if (font == "times" || font == "palatino"
3384 || font == "helvet" || font == "courier")
3385 return LaTeXFeatures::isAvailable("psnfss");
3386 if (font == "cmbr" || font == "cmtl")
3387 return LaTeXFeatures::isAvailable("cmbright");
3388 if (font == "utopia")
3389 return LaTeXFeatures::isAvailable("utopia")
3390 || LaTeXFeatures::isAvailable("fourier");
3391 if (font == "beraserif" || font == "berasans"
3392 || font == "beramono")
3393 return LaTeXFeatures::isAvailable("bera");
3394 return LaTeXFeatures::isAvailable(font);
3398 bool GuiDocument::providesOSF(string const & font) const
3400 if (fontModule->osFontsCB->isChecked())
3401 // FIXME: we should check if the fonts really
3402 // have OSF support. But how?
3405 return isFontAvailable("eco");
3406 if (font == "palatino")
3407 return isFontAvailable("mathpazo");
3412 bool GuiDocument::providesSC(string const & font) const
3414 if (fontModule->osFontsCB->isChecked())
3416 if (font == "palatino")
3417 return isFontAvailable("mathpazo");
3418 if (font == "utopia")
3419 return isFontAvailable("fourier");
3424 bool GuiDocument::providesScale(string const & font) const
3426 if (fontModule->osFontsCB->isChecked())
3428 return font == "helvet" || font == "luximono"
3429 || font == "berasans" || font == "beramono";
3433 void GuiDocument::loadModuleInfo()
3435 moduleNames_.clear();
3436 LyXModuleList::const_iterator it = theModuleList.begin();
3437 LyXModuleList::const_iterator end = theModuleList.end();
3438 for (; it != end; ++it) {
3442 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3443 // this is supposed to give us the first sentence of the description
3446 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3447 int const pos = desc.indexOf(".");
3449 desc.truncate(pos + 1);
3450 m.description = desc;
3451 moduleNames_.push_back(m);
3456 void GuiDocument::updateUnknownBranches()
3460 list<docstring> used_branches;
3461 buffer().getUsedBranches(used_branches);
3462 list<docstring>::const_iterator it = used_branches.begin();
3463 QStringList unknown_branches;
3464 for (; it != used_branches.end() ; ++it) {
3465 if (!buffer().params().branchlist().find(*it))
3466 unknown_branches.append(toqstr(*it));
3468 branchesModule->setUnknownBranches(unknown_branches);
3472 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3474 map<docstring, docstring>::iterator it = changedBranches_.begin();
3475 for (; it != changedBranches_.end() ; ++it) {
3476 if (it->second == oldname) {
3477 // branch has already been renamed
3478 it->second = newname;
3483 changedBranches_[oldname] = newname;
3487 void GuiDocument::executeBranchRenaming() const
3489 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3490 for (; it != changedBranches_.end() ; ++it) {
3491 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3492 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3497 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3500 } // namespace frontend
3503 #include "moc_GuiDocument.cpp"