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()));
540 connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
544 void LocalLayout::update(BufferParams const & params, BufferId id)
546 QString layout = toqstr(params.local_layout);
547 // Nothing to do if the params and preamble are unchanged.
548 if (id == current_id_
549 && layout == locallayoutTE->document()->toPlainText())
552 // Save the params address for further use.
554 locallayoutTE->document()->setPlainText(layout);
559 void LocalLayout::apply(BufferParams & params)
561 string const layout = fromqstr(locallayoutTE->document()->toPlainText());
562 params.local_layout = layout;
566 void LocalLayout::textChanged()
568 static const QString unknown = qt_("Press button to check validity...");
571 validLB->setText(unknown);
572 validatePB->setEnabled(true);
573 convertPB->setEnabled(false);
578 void LocalLayout::convert() {
579 string const layout =
580 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
581 string const newlayout = TextClass::convert(layout);
583 if (newlayout.empty()) {
584 Alert::error(_("Conversion Failed!"),
585 _("Failed to convert local layout to current format."));
587 locallayoutTE->setPlainText(toqstr(newlayout));
593 void LocalLayout::convertPressed() {
599 void LocalLayout::validate() {
600 static const QString valid = qt_("Layout is valid!");
601 static const QString vtext =
602 toqstr("<p style=\"font-weight: bold; \">")
603 + valid + toqstr("</p>");
604 static const QString invalid = qt_("Layout is invalid!");
605 static const QString ivtext =
606 toqstr("<p style=\"color: #c00000; font-weight: bold; \">")
607 + invalid + toqstr("</p>");
609 string const layout =
610 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
611 if (layout.empty()) {
613 validatePB->setEnabled(false);
614 validLB->setText("");
618 TextClass::ReturnValues const ret = TextClass::validate(layout);
619 is_valid_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
620 validatePB->setEnabled(false);
621 validLB->setText(is_valid_ ? vtext : ivtext);
622 if (ret == TextClass::OK_OLDFORMAT) {
624 convertPB->setEnabled(true);
625 convertLB->setText(qt_("Convert to current format"));
635 void LocalLayout::validatePressed() {
641 /////////////////////////////////////////////////////////////////////
645 /////////////////////////////////////////////////////////////////////
648 GuiDocument::GuiDocument(GuiView & lv)
649 : GuiDialog(lv, "document", qt_("Document Settings"))
653 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
654 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
655 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
656 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
658 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
659 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
661 // Manage the restore, ok, apply, restore and cancel/close buttons
662 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
664 bc().setApply(applyPB);
665 bc().setCancel(closePB);
666 bc().setRestore(restorePB);
670 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
671 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
672 this, SLOT(change_adaptor()));
673 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
674 this, SLOT(setLSpacing(int)));
675 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
676 this, SLOT(change_adaptor()));
678 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
679 this, SLOT(change_adaptor()));
680 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
681 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
682 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
683 this, SLOT(change_adaptor()));
684 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
685 this, SLOT(setIndent(int)));
686 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
687 this, SLOT(change_adaptor()));
688 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
689 this, SLOT(change_adaptor()));
691 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
692 this, SLOT(change_adaptor()));
693 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
694 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
695 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
696 this, SLOT(change_adaptor()));
697 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
698 this, SLOT(setSkip(int)));
699 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
700 this, SLOT(change_adaptor()));
701 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
702 this, SLOT(change_adaptor()));
704 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
705 this, SLOT(enableIndent(bool)));
706 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
707 this, SLOT(enableSkip(bool)));
709 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
710 this, SLOT(change_adaptor()));
711 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
712 this, SLOT(setColSep()));
714 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
715 textLayoutModule->lspacingLE));
716 textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
717 textLayoutModule->indentLE));
718 textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
719 textLayoutModule->skipLE));
721 textLayoutModule->indentCO->addItem(qt_("Default"));
722 textLayoutModule->indentCO->addItem(qt_("Custom"));
723 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
724 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
725 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
726 textLayoutModule->skipCO->addItem(qt_("Custom"));
727 textLayoutModule->lspacingCO->insertItem(
728 Spacing::Single, qt_("Single"));
729 textLayoutModule->lspacingCO->insertItem(
730 Spacing::Onehalf, qt_("OneHalf"));
731 textLayoutModule->lspacingCO->insertItem(
732 Spacing::Double, qt_("Double"));
733 textLayoutModule->lspacingCO->insertItem(
734 Spacing::Other, qt_("Custom"));
735 // initialize the length validator
736 bc().addCheckedLineEdit(textLayoutModule->indentLE);
737 bc().addCheckedLineEdit(textLayoutModule->skipLE);
740 // master/child handling
741 masterChildModule = new UiWidget<Ui::MasterChildUi>;
743 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
744 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
745 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
746 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
747 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
748 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
749 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
750 this, SLOT(change_adaptor()));
751 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
752 this, SLOT(change_adaptor()));
753 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
754 this, SLOT(change_adaptor()));
755 masterChildModule->childrenTW->setColumnCount(2);
756 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
757 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
758 masterChildModule->childrenTW->resizeColumnToContents(1);
759 masterChildModule->childrenTW->resizeColumnToContents(2);
763 outputModule = new UiWidget<Ui::OutputUi>;
765 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
766 this, SLOT(change_adaptor()));
767 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
768 this, SLOT(change_adaptor()));
769 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
770 this, SLOT(change_adaptor()));
771 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
772 this, SLOT(change_adaptor()));
774 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
775 this, SLOT(change_adaptor()));
776 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
777 this, SLOT(change_adaptor()));
778 outputModule->synccustomCB->addItem("");
779 outputModule->synccustomCB->addItem("\\synctex=1");
780 outputModule->synccustomCB->addItem("\\synctex=-1");
781 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
784 fontModule = new UiWidget<Ui::FontUi>;
785 connect(fontModule->osFontsCB, SIGNAL(clicked()),
786 this, SLOT(change_adaptor()));
787 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
788 this, SLOT(osFontsChanged(bool)));
789 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
790 this, SLOT(change_adaptor()));
791 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
792 this, SLOT(romanChanged(int)));
793 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
794 this, SLOT(change_adaptor()));
795 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
796 this, SLOT(sansChanged(int)));
797 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
798 this, SLOT(change_adaptor()));
799 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
800 this, SLOT(ttChanged(int)));
801 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
802 this, SLOT(change_adaptor()));
803 connect(fontModule->fontencCO, SIGNAL(activated(int)),
804 this, SLOT(change_adaptor()));
805 connect(fontModule->fontencCO, SIGNAL(activated(int)),
806 this, SLOT(fontencChanged(int)));
807 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
808 this, SLOT(change_adaptor()));
809 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
810 this, SLOT(change_adaptor()));
811 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
812 this, SLOT(change_adaptor()));
813 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
814 this, SLOT(change_adaptor()));
815 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
816 this, SLOT(change_adaptor()));
817 connect(fontModule->fontScCB, SIGNAL(clicked()),
818 this, SLOT(change_adaptor()));
819 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
820 this, SLOT(change_adaptor()));
824 fontModule->fontsizeCO->addItem(qt_("Default"));
825 fontModule->fontsizeCO->addItem(qt_("10"));
826 fontModule->fontsizeCO->addItem(qt_("11"));
827 fontModule->fontsizeCO->addItem(qt_("12"));
829 fontModule->fontencCO->addItem(qt_("Default"));
830 fontModule->fontencCO->addItem(qt_("Custom"));
831 fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
833 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
834 fontModule->fontsDefaultCO->addItem(
835 qt_(GuiDocument::fontfamilies_gui[n]));
837 if (!LaTeXFeatures::isAvailable("fontspec"))
838 fontModule->osFontsCB->setToolTip(
839 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
840 "You need to install the package \"fontspec\" to use this feature"));
844 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
845 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
846 this, SLOT(papersizeChanged(int)));
847 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
848 this, SLOT(papersizeChanged(int)));
849 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
850 this, SLOT(change_adaptor()));
851 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
852 this, SLOT(change_adaptor()));
853 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
854 this, SLOT(change_adaptor()));
855 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
856 this, SLOT(change_adaptor()));
857 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
858 this, SLOT(change_adaptor()));
859 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
860 this, SLOT(change_adaptor()));
861 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
862 this, SLOT(change_adaptor()));
863 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
864 this, SLOT(change_adaptor()));
865 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
866 this, SLOT(change_adaptor()));
867 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
868 this, SLOT(change_adaptor()));
870 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
871 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
872 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
873 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
874 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
875 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
876 pageLayoutModule->paperheightL);
877 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
878 pageLayoutModule->paperwidthL);
880 QComboBox * cb = pageLayoutModule->papersizeCO;
881 cb->addItem(qt_("Default"));
882 cb->addItem(qt_("Custom"));
883 cb->addItem(qt_("US letter"));
884 cb->addItem(qt_("US legal"));
885 cb->addItem(qt_("US executive"));
886 cb->addItem(qt_("A0"));
887 cb->addItem(qt_("A1"));
888 cb->addItem(qt_("A2"));
889 cb->addItem(qt_("A3"));
890 cb->addItem(qt_("A4"));
891 cb->addItem(qt_("A5"));
892 cb->addItem(qt_("A6"));
893 cb->addItem(qt_("B0"));
894 cb->addItem(qt_("B1"));
895 cb->addItem(qt_("B2"));
896 cb->addItem(qt_("B3"));
897 cb->addItem(qt_("B4"));
898 cb->addItem(qt_("B5"));
899 cb->addItem(qt_("B6"));
900 cb->addItem(qt_("C0"));
901 cb->addItem(qt_("C1"));
902 cb->addItem(qt_("C2"));
903 cb->addItem(qt_("C3"));
904 cb->addItem(qt_("C4"));
905 cb->addItem(qt_("C5"));
906 cb->addItem(qt_("C6"));
907 cb->addItem(qt_("JIS B0"));
908 cb->addItem(qt_("JIS B1"));
909 cb->addItem(qt_("JIS B2"));
910 cb->addItem(qt_("JIS B3"));
911 cb->addItem(qt_("JIS B4"));
912 cb->addItem(qt_("JIS B5"));
913 cb->addItem(qt_("JIS B6"));
914 // remove the %-items from the unit choice
915 pageLayoutModule->paperwidthUnitCO->noPercents();
916 pageLayoutModule->paperheightUnitCO->noPercents();
917 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
918 pageLayoutModule->paperheightLE));
919 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
920 pageLayoutModule->paperwidthLE));
924 marginsModule = new UiWidget<Ui::MarginsUi>;
925 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
926 this, SLOT(setCustomMargins(bool)));
927 connect(marginsModule->marginCB, SIGNAL(clicked()),
928 this, SLOT(change_adaptor()));
929 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
930 this, SLOT(change_adaptor()));
931 connect(marginsModule->topUnit, SIGNAL(activated(int)),
932 this, SLOT(change_adaptor()));
933 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
934 this, SLOT(change_adaptor()));
935 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
936 this, SLOT(change_adaptor()));
937 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
938 this, SLOT(change_adaptor()));
939 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
940 this, SLOT(change_adaptor()));
941 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
942 this, SLOT(change_adaptor()));
943 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
944 this, SLOT(change_adaptor()));
945 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
946 this, SLOT(change_adaptor()));
947 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
948 this, SLOT(change_adaptor()));
949 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
950 this, SLOT(change_adaptor()));
951 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
952 this, SLOT(change_adaptor()));
953 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
954 this, SLOT(change_adaptor()));
955 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
956 this, SLOT(change_adaptor()));
957 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
958 this, SLOT(change_adaptor()));
959 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
960 this, SLOT(change_adaptor()));
961 marginsModule->topLE->setValidator(unsignedLengthValidator(
962 marginsModule->topLE));
963 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
964 marginsModule->bottomLE));
965 marginsModule->innerLE->setValidator(unsignedLengthValidator(
966 marginsModule->innerLE));
967 marginsModule->outerLE->setValidator(unsignedLengthValidator(
968 marginsModule->outerLE));
969 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
970 marginsModule->headsepLE));
971 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
972 marginsModule->headheightLE));
973 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
974 marginsModule->footskipLE));
975 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
976 marginsModule->columnsepLE));
978 bc().addCheckedLineEdit(marginsModule->topLE,
979 marginsModule->topL);
980 bc().addCheckedLineEdit(marginsModule->bottomLE,
981 marginsModule->bottomL);
982 bc().addCheckedLineEdit(marginsModule->innerLE,
983 marginsModule->innerL);
984 bc().addCheckedLineEdit(marginsModule->outerLE,
985 marginsModule->outerL);
986 bc().addCheckedLineEdit(marginsModule->headsepLE,
987 marginsModule->headsepL);
988 bc().addCheckedLineEdit(marginsModule->headheightLE,
989 marginsModule->headheightL);
990 bc().addCheckedLineEdit(marginsModule->footskipLE,
991 marginsModule->footskipL);
992 bc().addCheckedLineEdit(marginsModule->columnsepLE,
993 marginsModule->columnsepL);
997 langModule = new UiWidget<Ui::LanguageUi>;
998 connect(langModule->languageCO, SIGNAL(activated(int)),
999 this, SLOT(change_adaptor()));
1000 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1001 this, SLOT(change_adaptor()));
1002 connect(langModule->otherencodingRB, SIGNAL(clicked()),
1003 this, SLOT(change_adaptor()));
1004 connect(langModule->encodingCO, SIGNAL(activated(int)),
1005 this, SLOT(change_adaptor()));
1006 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1007 this, SLOT(change_adaptor()));
1008 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1009 this, SLOT(change_adaptor()));
1010 connect(langModule->languagePackageED, SIGNAL(textChanged(QString)),
1011 this, SLOT(change_adaptor()));
1012 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1013 this, SLOT(languagePackageChanged(int)));
1015 QAbstractItemModel * language_model = guiApp->languageModel();
1016 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1017 language_model->sort(0);
1018 langModule->languageCO->setModel(language_model);
1019 langModule->languageCO->setModelColumn(0);
1021 // Always put the default encoding in the first position.
1022 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1023 QStringList encodinglist;
1024 Encodings::const_iterator it = encodings.begin();
1025 Encodings::const_iterator const end = encodings.end();
1026 for (; it != end; ++it)
1027 encodinglist.append(qt_(it->guiName()));
1028 encodinglist.sort();
1029 langModule->encodingCO->addItems(encodinglist);
1031 langModule->quoteStyleCO->addItem(qt_("``text''"));
1032 langModule->quoteStyleCO->addItem(qt_("''text''"));
1033 langModule->quoteStyleCO->addItem(qt_(",,text``"));
1034 langModule->quoteStyleCO->addItem(qt_(",,text''"));
1035 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
1036 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
1038 langModule->languagePackageCO->addItem(
1039 qt_("Default"), toqstr("default"));
1040 langModule->languagePackageCO->addItem(
1041 qt_("Automatic"), toqstr("auto"));
1042 langModule->languagePackageCO->addItem(
1043 qt_("Always Babel"), toqstr("babel"));
1044 langModule->languagePackageCO->addItem(
1045 qt_("Custom"), toqstr("custom"));
1046 langModule->languagePackageCO->addItem(
1047 qt_("None[[language package]]"), toqstr("none"));
1051 colorModule = new UiWidget<Ui::ColorUi>;
1052 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1053 this, SLOT(changeFontColor()));
1054 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1055 this, SLOT(deleteFontColor()));
1056 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1057 this, SLOT(changeNoteFontColor()));
1058 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1059 this, SLOT(deleteNoteFontColor()));
1060 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1061 this, SLOT(changeBackgroundColor()));
1062 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1063 this, SLOT(deleteBackgroundColor()));
1064 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1065 this, SLOT(changeBoxBackgroundColor()));
1066 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1067 this, SLOT(deleteBoxBackgroundColor()));
1071 numberingModule = new UiWidget<Ui::NumberingUi>;
1072 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1073 this, SLOT(change_adaptor()));
1074 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1075 this, SLOT(change_adaptor()));
1076 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1077 this, SLOT(updateNumbering()));
1078 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1079 this, SLOT(updateNumbering()));
1080 numberingModule->tocTW->setColumnCount(3);
1081 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1082 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1083 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1084 numberingModule->tocTW->header()->setResizeMode(QHeaderView::ResizeToContents);
1088 biblioModule = new UiWidget<Ui::BiblioUi>;
1089 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1090 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1091 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1092 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1093 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1094 this, SLOT(change_adaptor()));
1095 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1096 this, SLOT(change_adaptor()));
1097 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1098 this, SLOT(change_adaptor()));
1099 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1100 this, SLOT(change_adaptor()));
1101 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1102 this, SLOT(change_adaptor()));
1103 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1104 this, SLOT(bibtexChanged(int)));
1105 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
1106 this, SLOT(change_adaptor()));
1108 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1109 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1110 biblioModule->citeStyleCO->setCurrentIndex(0);
1112 // NOTE: we do not provide "custom" here for security reasons!
1113 biblioModule->bibtexCO->clear();
1114 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1115 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1116 it != lyxrc.bibtex_alternatives.end(); ++it) {
1117 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1118 biblioModule->bibtexCO->addItem(command, command);
1123 indicesModule = new GuiIndices;
1124 connect(indicesModule, SIGNAL(changed()),
1125 this, SLOT(change_adaptor()));
1129 mathsModule = new UiWidget<Ui::MathsUi>;
1130 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1131 mathsModule->amsCB, SLOT(setDisabled(bool)));
1132 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1133 mathsModule->esintCB, SLOT(setDisabled(bool)));
1134 connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1135 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1136 connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1137 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1139 connect(mathsModule->amsCB, SIGNAL(clicked()),
1140 this, SLOT(change_adaptor()));
1141 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1142 this, SLOT(change_adaptor()));
1143 connect(mathsModule->esintCB, SIGNAL(clicked()),
1144 this, SLOT(change_adaptor()));
1145 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1146 this, SLOT(change_adaptor()));
1147 connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1148 this, SLOT(change_adaptor()));
1149 connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1150 this, SLOT(change_adaptor()));
1151 connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1152 this, SLOT(change_adaptor()));
1153 connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1154 this, SLOT(change_adaptor()));
1158 latexModule = new UiWidget<Ui::LaTeXUi>;
1159 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1160 this, SLOT(change_adaptor()));
1161 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1162 this, SLOT(change_adaptor()));
1163 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1164 this, SLOT(change_adaptor()));
1165 connect(latexModule->classCO, SIGNAL(activated(int)),
1166 this, SLOT(classChanged()));
1167 connect(latexModule->classCO, SIGNAL(activated(int)),
1168 this, SLOT(change_adaptor()));
1169 connect(latexModule->layoutPB, SIGNAL(clicked()),
1170 this, SLOT(browseLayout()));
1171 connect(latexModule->layoutPB, SIGNAL(clicked()),
1172 this, SLOT(change_adaptor()));
1173 connect(latexModule->childDocGB, SIGNAL(clicked()),
1174 this, SLOT(change_adaptor()));
1175 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1176 this, SLOT(change_adaptor()));
1177 connect(latexModule->childDocPB, SIGNAL(clicked()),
1178 this, SLOT(browseMaster()));
1179 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1180 this, SLOT(change_adaptor()));
1181 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1182 this, SLOT(change_adaptor()));
1184 // postscript drivers
1185 for (int n = 0; tex_graphics[n][0]; ++n) {
1186 QString enc = qt_(tex_graphics_gui[n]);
1187 latexModule->psdriverCO->addItem(enc);
1190 latexModule->classCO->setModel(&classes_model_);
1191 LayoutFileList const & bcl = LayoutFileList::get();
1192 vector<LayoutFileIndex> classList = bcl.classList();
1193 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1195 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1196 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1197 for (int i = 0; cit != cen; ++cit, ++i) {
1198 LayoutFile const & tc = bcl[*cit];
1199 docstring item = (tc.isTeXClassAvailable()) ?
1200 from_utf8(tc.description()) :
1201 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1202 classes_model_.insertRow(i, toqstr(item), *cit);
1207 branchesModule = new GuiBranches;
1208 connect(branchesModule, SIGNAL(changed()),
1209 this, SLOT(change_adaptor()));
1210 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1211 this, SLOT(branchesRename(docstring const &, docstring const &)));
1212 updateUnknownBranches();
1216 preambleModule = new PreambleModule;
1217 connect(preambleModule, SIGNAL(changed()),
1218 this, SLOT(change_adaptor()));
1220 localLayout = new LocalLayout;
1221 connect(localLayout, SIGNAL(changed()),
1222 this, SLOT(change_adaptor()));
1226 bulletsModule = new BulletsModule;
1227 connect(bulletsModule, SIGNAL(changed()),
1228 this, SLOT(change_adaptor()));
1232 modulesModule = new UiWidget<Ui::ModulesUi>;
1233 modulesModule->availableLV->header()->setVisible(false);
1234 modulesModule->availableLV->header()->setResizeMode(QHeaderView::ResizeToContents);
1235 modulesModule->availableLV->header()->setStretchLastSection(false);
1237 new ModuleSelectionManager(modulesModule->availableLV,
1238 modulesModule->selectedLV,
1239 modulesModule->addPB, modulesModule->deletePB,
1240 modulesModule->upPB, modulesModule->downPB,
1241 availableModel(), selectedModel(), this);
1242 connect(selectionManager, SIGNAL(updateHook()),
1243 this, SLOT(updateModuleInfo()));
1244 connect(selectionManager, SIGNAL(updateHook()),
1245 this, SLOT(change_adaptor()));
1246 connect(selectionManager, SIGNAL(selectionChanged()),
1247 this, SLOT(modulesChanged()));
1251 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1252 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1253 this, SLOT(change_adaptor()));
1254 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1255 this, SLOT(change_adaptor()));
1256 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1257 this, SLOT(change_adaptor()));
1258 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1259 this, SLOT(change_adaptor()));
1260 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1261 this, SLOT(change_adaptor()));
1262 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1263 this, SLOT(change_adaptor()));
1264 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1265 this, SLOT(change_adaptor()));
1266 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1267 this, SLOT(change_adaptor()));
1268 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1269 this, SLOT(change_adaptor()));
1270 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1271 this, SLOT(change_adaptor()));
1272 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1273 this, SLOT(change_adaptor()));
1274 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1275 this, SLOT(change_adaptor()));
1276 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1277 this, SLOT(change_adaptor()));
1278 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1279 this, SLOT(change_adaptor()));
1280 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1281 this, SLOT(change_adaptor()));
1282 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1283 this, SLOT(change_adaptor()));
1285 for (int i = 0; backref_opts[i][0]; ++i)
1286 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1290 floatModule = new FloatPlacement;
1291 connect(floatModule, SIGNAL(changed()),
1292 this, SLOT(change_adaptor()));
1296 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1297 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1298 this, SLOT(change_adaptor()));
1299 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1300 this, SLOT(change_adaptor()));
1301 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1302 this, SLOT(setListingsMessage()));
1303 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1304 this, SLOT(setListingsMessage()));
1305 listingsModule->listingsTB->setPlainText(
1306 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1310 docPS->addPanel(latexModule, qt_("Document Class"));
1311 docPS->addPanel(masterChildModule, qt_("Child Documents"));
1312 docPS->addPanel(modulesModule, qt_("Modules"));
1313 docPS->addPanel(localLayout, qt_("Local Layout"));
1314 docPS->addPanel(fontModule, qt_("Fonts"));
1315 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1316 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1317 docPS->addPanel(marginsModule, qt_("Page Margins"));
1318 docPS->addPanel(langModule, qt_("Language"));
1319 docPS->addPanel(colorModule, qt_("Colors"));
1320 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1321 docPS->addPanel(biblioModule, qt_("Bibliography"));
1322 docPS->addPanel(indicesModule, qt_("Indexes"));
1323 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1324 docPS->addPanel(mathsModule, qt_("Math Options"));
1325 docPS->addPanel(floatModule, qt_("Float Placement"));
1326 docPS->addPanel(listingsModule, qt_("Listings"));
1327 docPS->addPanel(bulletsModule, qt_("Bullets"));
1328 docPS->addPanel(branchesModule, qt_("Branches"));
1329 docPS->addPanel(outputModule, qt_("Output"));
1330 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1331 docPS->setCurrentPanel(qt_("Document Class"));
1332 // FIXME: hack to work around resizing bug in Qt >= 4.2
1333 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1334 #if QT_VERSION >= 0x040200
1335 docPS->updateGeometry();
1340 void GuiDocument::saveDefaultClicked()
1346 void GuiDocument::useDefaultsClicked()
1352 void GuiDocument::change_adaptor()
1358 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1363 string child = fromqstr(item->text(0));
1367 if (std::find(includeonlys_.begin(),
1368 includeonlys_.end(), child) != includeonlys_.end())
1369 includeonlys_.remove(child);
1371 includeonlys_.push_back(child);
1373 updateIncludeonlys();
1378 QString GuiDocument::validateListingsParameters()
1380 // use a cache here to avoid repeated validation
1381 // of the same parameters
1382 static string param_cache;
1383 static QString msg_cache;
1385 if (listingsModule->bypassCB->isChecked())
1388 string params = fromqstr(listingsModule->listingsED->toPlainText());
1389 if (params != param_cache) {
1390 param_cache = params;
1391 msg_cache = toqstr(InsetListingsParams(params).validate());
1397 void GuiDocument::setListingsMessage()
1399 static bool isOK = true;
1400 QString msg = validateListingsParameters();
1401 if (msg.isEmpty()) {
1405 // listingsTB->setTextColor("black");
1406 listingsModule->listingsTB->setPlainText(
1407 qt_("Input listings parameters below. "
1408 "Enter ? for a list of parameters."));
1411 // listingsTB->setTextColor("red");
1412 listingsModule->listingsTB->setPlainText(msg);
1417 void GuiDocument::setLSpacing(int item)
1419 textLayoutModule->lspacingLE->setEnabled(item == 3);
1423 void GuiDocument::setIndent(int item)
1425 bool const enable = (item == 1);
1426 textLayoutModule->indentLE->setEnabled(enable);
1427 textLayoutModule->indentLengthCO->setEnabled(enable);
1428 textLayoutModule->skipLE->setEnabled(false);
1429 textLayoutModule->skipLengthCO->setEnabled(false);
1434 void GuiDocument::enableIndent(bool indent)
1436 textLayoutModule->skipLE->setEnabled(!indent);
1437 textLayoutModule->skipLengthCO->setEnabled(!indent);
1439 setIndent(textLayoutModule->indentCO->currentIndex());
1443 void GuiDocument::setSkip(int item)
1445 bool const enable = (item == 3);
1446 textLayoutModule->skipLE->setEnabled(enable);
1447 textLayoutModule->skipLengthCO->setEnabled(enable);
1452 void GuiDocument::enableSkip(bool skip)
1454 textLayoutModule->indentLE->setEnabled(!skip);
1455 textLayoutModule->indentLengthCO->setEnabled(!skip);
1457 setSkip(textLayoutModule->skipCO->currentIndex());
1461 void GuiDocument::setMargins()
1463 bool const extern_geometry =
1464 documentClass().provides("geometry");
1465 marginsModule->marginCB->setEnabled(!extern_geometry);
1466 if (extern_geometry) {
1467 marginsModule->marginCB->setChecked(false);
1468 setCustomMargins(true);
1470 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1471 setCustomMargins(!bp_.use_geometry);
1476 void GuiDocument::papersizeChanged(int paper_size)
1478 setCustomPapersize(paper_size == 1);
1482 void GuiDocument::setCustomPapersize(bool custom)
1484 pageLayoutModule->paperwidthL->setEnabled(custom);
1485 pageLayoutModule->paperwidthLE->setEnabled(custom);
1486 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1487 pageLayoutModule->paperheightL->setEnabled(custom);
1488 pageLayoutModule->paperheightLE->setEnabled(custom);
1489 pageLayoutModule->paperheightLE->setFocus();
1490 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1494 void GuiDocument::setColSep()
1496 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1500 void GuiDocument::setCustomMargins(bool custom)
1502 marginsModule->topL->setEnabled(!custom);
1503 marginsModule->topLE->setEnabled(!custom);
1504 marginsModule->topUnit->setEnabled(!custom);
1506 marginsModule->bottomL->setEnabled(!custom);
1507 marginsModule->bottomLE->setEnabled(!custom);
1508 marginsModule->bottomUnit->setEnabled(!custom);
1510 marginsModule->innerL->setEnabled(!custom);
1511 marginsModule->innerLE->setEnabled(!custom);
1512 marginsModule->innerUnit->setEnabled(!custom);
1514 marginsModule->outerL->setEnabled(!custom);
1515 marginsModule->outerLE->setEnabled(!custom);
1516 marginsModule->outerUnit->setEnabled(!custom);
1518 marginsModule->headheightL->setEnabled(!custom);
1519 marginsModule->headheightLE->setEnabled(!custom);
1520 marginsModule->headheightUnit->setEnabled(!custom);
1522 marginsModule->headsepL->setEnabled(!custom);
1523 marginsModule->headsepLE->setEnabled(!custom);
1524 marginsModule->headsepUnit->setEnabled(!custom);
1526 marginsModule->footskipL->setEnabled(!custom);
1527 marginsModule->footskipLE->setEnabled(!custom);
1528 marginsModule->footskipUnit->setEnabled(!custom);
1530 bool const enableColSep = !custom &&
1531 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1532 marginsModule->columnsepL->setEnabled(enableColSep);
1533 marginsModule->columnsepLE->setEnabled(enableColSep);
1534 marginsModule->columnsepUnit->setEnabled(enableColSep);
1538 void GuiDocument::changeBackgroundColor()
1540 QColor const & newColor = QColorDialog::getColor(
1541 rgb2qcolor(set_backgroundcolor), asQWidget());
1542 if (!newColor.isValid())
1544 // set the button color and text
1545 colorModule->backgroundPB->setStyleSheet(
1546 colorButtonStyleSheet(newColor));
1547 colorModule->backgroundPB->setText(qt_("&Change..."));
1549 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1550 is_backgroundcolor = true;
1555 void GuiDocument::deleteBackgroundColor()
1557 // set the button color back to default by setting an empty StyleSheet
1558 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1559 // change button text
1560 colorModule->backgroundPB->setText(qt_("&Default..."));
1561 // save default color (white)
1562 set_backgroundcolor = rgbFromHexName("#ffffff");
1563 is_backgroundcolor = false;
1568 void GuiDocument::changeFontColor()
1570 QColor const & newColor = QColorDialog::getColor(
1571 rgb2qcolor(set_fontcolor), asQWidget());
1572 if (!newColor.isValid())
1574 // set the button color and text
1575 colorModule->fontColorPB->setStyleSheet(
1576 colorButtonStyleSheet(newColor));
1577 colorModule->fontColorPB->setText(qt_("&Change..."));
1579 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1580 is_fontcolor = true;
1585 void GuiDocument::deleteFontColor()
1587 // set the button color back to default by setting an empty StyleSheet
1588 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1589 // change button text
1590 colorModule->fontColorPB->setText(qt_("&Default..."));
1591 // save default color (black)
1592 set_fontcolor = rgbFromHexName("#000000");
1593 is_fontcolor = false;
1598 void GuiDocument::changeNoteFontColor()
1600 QColor const & newColor = QColorDialog::getColor(
1601 rgb2qcolor(set_notefontcolor), asQWidget());
1602 if (!newColor.isValid())
1604 // set the button color
1605 colorModule->noteFontColorPB->setStyleSheet(
1606 colorButtonStyleSheet(newColor));
1608 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1613 void GuiDocument::deleteNoteFontColor()
1615 // set the button color back to pref
1616 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1617 colorModule->noteFontColorPB->setStyleSheet(
1618 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1623 void GuiDocument::changeBoxBackgroundColor()
1625 QColor const & newColor = QColorDialog::getColor(
1626 rgb2qcolor(set_boxbgcolor), asQWidget());
1627 if (!newColor.isValid())
1629 // set the button color
1630 colorModule->boxBackgroundPB->setStyleSheet(
1631 colorButtonStyleSheet(newColor));
1633 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1638 void GuiDocument::deleteBoxBackgroundColor()
1640 // set the button color back to pref
1641 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1642 colorModule->boxBackgroundPB->setStyleSheet(
1643 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1648 void GuiDocument::osFontsChanged(bool nontexfonts)
1650 bool const tex_fonts = !nontexfonts;
1652 updateDefaultFormat();
1653 langModule->encodingCO->setEnabled(tex_fonts &&
1654 !langModule->defaultencodingRB->isChecked());
1655 langModule->defaultencodingRB->setEnabled(tex_fonts);
1656 langModule->otherencodingRB->setEnabled(tex_fonts);
1658 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1659 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1660 fontModule->cjkFontLE->setEnabled(tex_fonts);
1661 fontModule->cjkFontLA->setEnabled(tex_fonts);
1664 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1665 bool scaleable = providesScale(font);
1666 fontModule->scaleSansSB->setEnabled(scaleable);
1667 fontModule->scaleSansLA->setEnabled(scaleable);
1669 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1670 scaleable = providesScale(font);
1671 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1672 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1674 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1675 fontModule->fontScCB->setEnabled(providesSC(font));
1676 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1678 fontModule->fontencLA->setEnabled(tex_fonts);
1679 fontModule->fontencCO->setEnabled(tex_fonts);
1681 fontModule->fontencLE->setEnabled(false);
1683 fontencChanged(fontModule->fontencCO->currentIndex());
1687 void GuiDocument::updateFontsize(string const & items, string const & sel)
1689 fontModule->fontsizeCO->clear();
1690 fontModule->fontsizeCO->addItem(qt_("Default"));
1692 for (int n = 0; !token(items,'|',n).empty(); ++n)
1693 fontModule->fontsizeCO->
1694 addItem(toqstr(token(items,'|',n)));
1696 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1697 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1698 fontModule->fontsizeCO->setCurrentIndex(n);
1705 void GuiDocument::updateFontlist()
1707 fontModule->fontsRomanCO->clear();
1708 fontModule->fontsSansCO->clear();
1709 fontModule->fontsTypewriterCO->clear();
1711 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1712 if (fontModule->osFontsCB->isChecked()) {
1713 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1714 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1715 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1717 QFontDatabase fontdb;
1718 QStringList families(fontdb.families());
1719 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1720 fontModule->fontsRomanCO->addItem(*it, *it);
1721 fontModule->fontsSansCO->addItem(*it, *it);
1722 fontModule->fontsTypewriterCO->addItem(*it, *it);
1727 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1728 QString font = qt_(tex_fonts_roman_gui[n]);
1729 if (!isFontAvailable(tex_fonts_roman[n]))
1730 font += qt_(" (not installed)");
1731 fontModule->fontsRomanCO->addItem(font, qt_(tex_fonts_roman[n]));
1733 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1734 QString font = qt_(tex_fonts_sans_gui[n]);
1735 if (!isFontAvailable(tex_fonts_sans[n]))
1736 font += qt_(" (not installed)");
1737 fontModule->fontsSansCO->addItem(font, qt_(tex_fonts_sans[n]));
1739 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1740 QString font = qt_(tex_fonts_monospaced_gui[n]);
1741 if (!isFontAvailable(tex_fonts_monospaced[n]))
1742 font += qt_(" (not installed)");
1743 fontModule->fontsTypewriterCO->addItem(font, qt_(tex_fonts_monospaced[n]));
1748 void GuiDocument::fontencChanged(int item)
1750 fontModule->fontencLE->setEnabled(item == 1);
1754 void GuiDocument::romanChanged(int item)
1756 if (fontModule->osFontsCB->isChecked())
1758 string const font = tex_fonts_roman[item];
1759 fontModule->fontScCB->setEnabled(providesSC(font));
1760 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1764 void GuiDocument::sansChanged(int item)
1766 if (fontModule->osFontsCB->isChecked())
1768 string const font = tex_fonts_sans[item];
1769 bool scaleable = providesScale(font);
1770 fontModule->scaleSansSB->setEnabled(scaleable);
1771 fontModule->scaleSansLA->setEnabled(scaleable);
1775 void GuiDocument::ttChanged(int item)
1777 if (fontModule->osFontsCB->isChecked())
1779 string const font = tex_fonts_monospaced[item];
1780 bool scaleable = providesScale(font);
1781 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1782 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1786 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1789 pageLayoutModule->pagestyleCO->clear();
1790 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1792 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1793 string style = token(items, '|', n);
1794 QString style_gui = qt_(style);
1795 pagestyles.push_back(pair<string, QString>(style, style_gui));
1796 pageLayoutModule->pagestyleCO->addItem(style_gui);
1799 if (sel == "default") {
1800 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1806 for (size_t i = 0; i < pagestyles.size(); ++i)
1807 if (pagestyles[i].first == sel)
1808 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1811 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1815 void GuiDocument::browseLayout()
1817 QString const label1 = qt_("Layouts|#o#O");
1818 QString const dir1 = toqstr(lyxrc.document_path);
1819 QStringList const filter(qt_("LyX Layout (*.layout)"));
1820 QString file = browseRelToParent(QString(), bufferFilePath(),
1821 qt_("Local layout file"), filter, false,
1824 if (!file.endsWith(".layout"))
1827 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1828 fromqstr(bufferFilePath()));
1830 int const ret = Alert::prompt(_("Local layout file"),
1831 _("The layout file you have selected is a local layout\n"
1832 "file, not one in the system or user directory. Your\n"
1833 "document may not work with this layout if you do not\n"
1834 "keep the layout file in the document directory."),
1835 1, 1, _("&Set Layout"), _("&Cancel"));
1839 // load the layout file
1840 LayoutFileList & bcl = LayoutFileList::get();
1841 string classname = layoutFile.onlyFileName();
1842 // this will update an existing layout if that layout has been loaded before.
1843 LayoutFileIndex name = bcl.addLocalLayout(
1844 classname.substr(0, classname.size() - 7),
1845 layoutFile.onlyPath().absFileName());
1848 Alert::error(_("Error"),
1849 _("Unable to read local layout file."));
1853 // do not trigger classChanged if there is no change.
1854 if (latexModule->classCO->currentText() == toqstr(name))
1858 int idx = latexModule->classCO->findText(toqstr(name));
1860 classes_model_.insertRow(0, toqstr(name), name);
1861 latexModule->classCO->setCurrentIndex(0);
1863 latexModule->classCO->setCurrentIndex(idx);
1869 void GuiDocument::browseMaster()
1871 QString const title = qt_("Select master document");
1872 QString const dir1 = toqstr(lyxrc.document_path);
1873 QString const old = latexModule->childDocLE->text();
1874 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1875 QStringList const filter(qt_("LyX Files (*.lyx)"));
1876 QString file = browseRelToSub(old, docpath, title, filter, false,
1877 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1879 if (!file.isEmpty())
1880 latexModule->childDocLE->setText(file);
1884 void GuiDocument::classChanged()
1886 int idx = latexModule->classCO->currentIndex();
1889 string const classname = classes_model_.getIDString(idx);
1891 // check whether the selected modules have changed.
1892 bool modules_changed = false;
1893 unsigned int const srows = selectedModel()->rowCount();
1894 if (srows != bp_.getModules().size())
1895 modules_changed = true;
1897 list<string>::const_iterator mit = bp_.getModules().begin();
1898 list<string>::const_iterator men = bp_.getModules().end();
1899 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1900 if (selectedModel()->getIDString(i) != *mit) {
1901 modules_changed = true;
1906 if (modules_changed || lyxrc.auto_reset_options) {
1907 if (applyPB->isEnabled()) {
1908 int const ret = Alert::prompt(_("Unapplied changes"),
1909 _("Some changes in the dialog were not yet applied.\n"
1910 "If you do not apply now, they will be lost after this action."),
1911 1, 1, _("&Apply"), _("&Dismiss"));
1917 // We load the TextClass as soon as it is selected. This is
1918 // necessary so that other options in the dialog can be updated
1919 // according to the new class. Note, however, that, if you use
1920 // the scroll wheel when sitting on the combo box, we'll load a
1921 // lot of TextClass objects very quickly....
1922 if (!bp_.setBaseClass(classname)) {
1923 Alert::error(_("Error"), _("Unable to set document class."));
1926 if (lyxrc.auto_reset_options)
1927 bp_.useClassDefaults();
1929 // With the introduction of modules came a distinction between the base
1930 // class and the document class. The former corresponds to the main layout
1931 // file; the latter is that plus the modules (or the document-specific layout,
1932 // or whatever else there could be). Our parameters come from the document
1933 // class. So when we set the base class, we also need to recreate the document
1934 // class. Otherwise, we still have the old one.
1935 bp_.makeDocumentClass();
1940 void GuiDocument::languagePackageChanged(int i)
1942 langModule->languagePackageED->setEnabled(
1943 langModule->languagePackageCO->itemData(i).toString() == "custom");
1947 void GuiDocument::bibtexChanged(int n)
1949 biblioModule->bibtexOptionsED->setEnabled(
1950 biblioModule->bibtexCO->itemData(n).toString() != "default");
1957 // both of these should take a vector<docstring>
1959 // This is an insanely complicated attempt to make this sort of thing
1960 // work with RTL languages.
1961 docstring formatStrVec(vector<string> const & v, docstring const & s)
1963 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1967 return translateIfPossible(from_utf8(v[0]));
1968 if (v.size() == 2) {
1969 docstring retval = _("%1$s and %2$s");
1970 retval = subst(retval, _("and"), s);
1971 return bformat(retval, translateIfPossible(from_utf8(v[0])),
1972 translateIfPossible(from_utf8(v[1])));
1974 // The idea here is to format all but the last two items...
1975 int const vSize = v.size();
1976 docstring t2 = _("%1$s, %2$s");
1977 docstring retval = translateIfPossible(from_utf8(v[0]));
1978 for (int i = 1; i < vSize - 2; ++i)
1979 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
1980 //...and then to plug them, and the last two, into this schema
1981 docstring t = _("%1$s, %2$s, and %3$s");
1982 t = subst(t, _("and"), s);
1983 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
1984 translateIfPossible(from_utf8(v[vSize - 1])));
1987 vector<string> idsToNames(vector<string> const & idList)
1989 vector<string> retval;
1990 vector<string>::const_iterator it = idList.begin();
1991 vector<string>::const_iterator end = idList.end();
1992 for (; it != end; ++it) {
1993 LyXModule const * const mod = theModuleList[*it];
1995 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
1996 translateIfPossible(from_utf8(*it)))));
1998 retval.push_back(mod->getName());
2002 } // end anonymous namespace
2005 void GuiDocument::modulesToParams(BufferParams & bp)
2007 // update list of loaded modules
2008 bp.clearLayoutModules();
2009 int const srows = modules_sel_model_.rowCount();
2010 for (int i = 0; i < srows; ++i)
2011 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2013 // update the list of removed modules
2014 bp.clearRemovedModules();
2015 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2016 list<string>::const_iterator rit = reqmods.begin();
2017 list<string>::const_iterator ren = reqmods.end();
2019 // check each of the default modules
2020 for (; rit != ren; rit++) {
2021 list<string>::const_iterator mit = bp.getModules().begin();
2022 list<string>::const_iterator men = bp.getModules().end();
2024 for (; mit != men; mit++) {
2031 // the module isn't present so must have been removed by the user
2032 bp.addRemovedModule(*rit);
2037 void GuiDocument::modulesChanged()
2039 modulesToParams(bp_);
2040 bp_.makeDocumentClass();
2045 void GuiDocument::updateModuleInfo()
2047 selectionManager->update();
2049 //Module description
2050 bool const focus_on_selected = selectionManager->selectedFocused();
2051 QAbstractItemView * lv;
2052 if (focus_on_selected)
2053 lv = modulesModule->selectedLV;
2055 lv= modulesModule->availableLV;
2056 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2057 modulesModule->infoML->document()->clear();
2060 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2061 GuiIdListModel const & id_model =
2062 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2063 string const modName = id_model.getIDString(idx.row());
2064 docstring desc = getModuleDescription(modName);
2066 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2067 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2070 desc += _("Module provided by document class.");
2073 vector<string> pkglist = getPackageList(modName);
2074 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2075 if (!pkgdesc.empty()) {
2078 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2081 pkglist = getRequiredList(modName);
2082 if (!pkglist.empty()) {
2083 vector<string> const reqdescs = idsToNames(pkglist);
2084 pkgdesc = formatStrVec(reqdescs, _("or"));
2087 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2090 pkglist = getExcludedList(modName);
2091 if (!pkglist.empty()) {
2092 vector<string> const reqdescs = idsToNames(pkglist);
2093 pkgdesc = formatStrVec(reqdescs, _( "and"));
2096 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2099 if (!isModuleAvailable(modName)) {
2102 desc += _("WARNING: Some required packages are unavailable!");
2105 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2109 void GuiDocument::updateNumbering()
2111 DocumentClass const & tclass = documentClass();
2113 numberingModule->tocTW->setUpdatesEnabled(false);
2114 numberingModule->tocTW->clear();
2116 int const depth = numberingModule->depthSL->value();
2117 int const toc = numberingModule->tocSL->value();
2118 QString const no = qt_("No");
2119 QString const yes = qt_("Yes");
2120 QTreeWidgetItem * item = 0;
2122 DocumentClass::const_iterator lit = tclass.begin();
2123 DocumentClass::const_iterator len = tclass.end();
2124 for (; lit != len; ++lit) {
2125 int const toclevel = lit->toclevel;
2126 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2127 item = new QTreeWidgetItem(numberingModule->tocTW);
2128 item->setText(0, toqstr(translateIfPossible(lit->name())));
2129 item->setText(1, (toclevel <= depth) ? yes : no);
2130 item->setText(2, (toclevel <= toc) ? yes : no);
2134 numberingModule->tocTW->setUpdatesEnabled(true);
2135 numberingModule->tocTW->update();
2139 void GuiDocument::updateDefaultFormat()
2143 // make a copy in order to consider unapplied changes
2144 BufferParams param_copy = buffer().params();
2145 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2146 int const idx = latexModule->classCO->currentIndex();
2148 string const classname = classes_model_.getIDString(idx);
2149 param_copy.setBaseClass(classname);
2150 param_copy.makeDocumentClass();
2152 outputModule->defaultFormatCO->blockSignals(true);
2153 outputModule->defaultFormatCO->clear();
2154 outputModule->defaultFormatCO->addItem(qt_("Default"),
2155 QVariant(QString("default")));
2156 typedef vector<Format const *> Formats;
2157 Formats formats = param_copy.exportableFormats(true);
2158 Formats::const_iterator cit = formats.begin();
2159 Formats::const_iterator end = formats.end();
2160 for (; cit != end; ++cit)
2161 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2162 QVariant(toqstr((*cit)->name())));
2163 outputModule->defaultFormatCO->blockSignals(false);
2167 bool GuiDocument::isChildIncluded(string const & child)
2169 if (includeonlys_.empty())
2171 return (std::find(includeonlys_.begin(),
2172 includeonlys_.end(), child) != includeonlys_.end());
2176 void GuiDocument::applyView()
2179 preambleModule->apply(bp_);
2180 localLayout->apply(bp_);
2183 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2184 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2187 bp_.setCiteEngine(ENGINE_BASIC);
2189 if (biblioModule->citeNatbibRB->isChecked()) {
2190 bool const use_numerical_citations =
2191 biblioModule->citeStyleCO->currentIndex();
2192 if (use_numerical_citations)
2193 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2195 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2197 } else if (biblioModule->citeJurabibRB->isChecked())
2198 bp_.setCiteEngine(ENGINE_JURABIB);
2201 biblioModule->bibtopicCB->isChecked();
2203 string const bibtex_command =
2204 fromqstr(biblioModule->bibtexCO->itemData(
2205 biblioModule->bibtexCO->currentIndex()).toString());
2206 string const bibtex_options =
2207 fromqstr(biblioModule->bibtexOptionsED->text());
2208 if (bibtex_command == "default" || bibtex_options.empty())
2209 bp_.bibtex_command = bibtex_command;
2211 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2214 indicesModule->apply(bp_);
2216 // language & quotes
2217 if (langModule->defaultencodingRB->isChecked()) {
2218 bp_.inputenc = "auto";
2220 int i = langModule->encodingCO->currentIndex();
2222 bp_.inputenc = "default";
2224 QString const enc_gui =
2225 langModule->encodingCO->currentText();
2226 Encodings::const_iterator it = encodings.begin();
2227 Encodings::const_iterator const end = encodings.end();
2229 for (; it != end; ++it) {
2230 if (qt_(it->guiName()) == enc_gui) {
2231 bp_.inputenc = it->latexName();
2237 // should not happen
2238 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2239 bp_.inputenc = "default";
2244 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2245 switch (langModule->quoteStyleCO->currentIndex()) {
2247 lga = InsetQuotes::EnglishQuotes;
2250 lga = InsetQuotes::SwedishQuotes;
2253 lga = InsetQuotes::GermanQuotes;
2256 lga = InsetQuotes::PolishQuotes;
2259 lga = InsetQuotes::FrenchQuotes;
2262 lga = InsetQuotes::DanishQuotes;
2265 bp_.quotes_language = lga;
2267 QString const lang = langModule->languageCO->itemData(
2268 langModule->languageCO->currentIndex()).toString();
2269 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2271 QString const pack = langModule->languagePackageCO->itemData(
2272 langModule->languagePackageCO->currentIndex()).toString();
2273 if (pack == "custom")
2275 fromqstr(langModule->languagePackageED->text());
2277 bp_.lang_package = fromqstr(pack);
2280 bp_.backgroundcolor = set_backgroundcolor;
2281 bp_.isbackgroundcolor = is_backgroundcolor;
2282 bp_.fontcolor = set_fontcolor;
2283 bp_.isfontcolor = is_fontcolor;
2284 bp_.notefontcolor = set_notefontcolor;
2285 bp_.boxbgcolor = set_boxbgcolor;
2288 if (bp_.documentClass().hasTocLevels()) {
2289 bp_.tocdepth = numberingModule->tocSL->value();
2290 bp_.secnumdepth = numberingModule->depthSL->value();
2294 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2295 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2296 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2297 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2300 bp_.graphics_driver =
2301 tex_graphics[latexModule->psdriverCO->currentIndex()];
2304 int idx = latexModule->classCO->currentIndex();
2306 string const classname = classes_model_.getIDString(idx);
2307 bp_.setBaseClass(classname);
2311 modulesToParams(bp_);
2314 if (mathsModule->amsautoCB->isChecked())
2315 bp_.use_amsmath = BufferParams::package_auto;
2317 if (mathsModule->amsCB->isChecked())
2318 bp_.use_amsmath = BufferParams::package_on;
2320 bp_.use_amsmath = BufferParams::package_off;
2322 if (mathsModule->esintautoCB->isChecked())
2323 bp_.use_esint = BufferParams::package_auto;
2325 if (mathsModule->esintCB->isChecked())
2326 bp_.use_esint = BufferParams::package_on;
2328 bp_.use_esint = BufferParams::package_off;
2330 if (mathsModule->mhchemautoCB->isChecked())
2331 bp_.use_mhchem = BufferParams::package_auto;
2333 if (mathsModule->mhchemCB->isChecked())
2334 bp_.use_mhchem = BufferParams::package_on;
2336 bp_.use_mhchem = BufferParams::package_off;
2338 if (mathsModule->mathdotsautoCB->isChecked())
2339 bp_.use_mathdots = BufferParams::package_auto;
2341 if (mathsModule->mathdotsCB->isChecked())
2342 bp_.use_mathdots = BufferParams::package_on;
2344 bp_.use_mathdots = BufferParams::package_off;
2348 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2349 bp_.pagestyle = "default";
2351 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2352 for (size_t i = 0; i != pagestyles.size(); ++i)
2353 if (pagestyles[i].second == style_gui)
2354 bp_.pagestyle = pagestyles[i].first;
2358 switch (textLayoutModule->lspacingCO->currentIndex()) {
2360 bp_.spacing().set(Spacing::Single);
2363 bp_.spacing().set(Spacing::Onehalf);
2366 bp_.spacing().set(Spacing::Double);
2369 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2371 bp_.spacing().set(Spacing::Single);
2373 bp_.spacing().set(Spacing::Other, s);
2378 if (textLayoutModule->twoColumnCB->isChecked())
2383 if (textLayoutModule->indentRB->isChecked()) {
2384 // if paragraphs are separated by an indentation
2385 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2386 switch (textLayoutModule->indentCO->currentIndex()) {
2388 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2391 HSpace indent = HSpace(
2392 widgetsToLength(textLayoutModule->indentLE,
2393 textLayoutModule->indentLengthCO)
2395 bp_.setIndentation(indent);
2399 // this should never happen
2400 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2404 // if paragraphs are separated by a skip
2405 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2406 switch (textLayoutModule->skipCO->currentIndex()) {
2408 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2411 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2414 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2419 widgetsToLength(textLayoutModule->skipLE,
2420 textLayoutModule->skipLengthCO)
2426 // this should never happen
2427 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2433 fromqstr(latexModule->optionsLE->text());
2435 bp_.use_default_options =
2436 latexModule->defaultOptionsCB->isChecked();
2438 if (latexModule->childDocGB->isChecked())
2440 fromqstr(latexModule->childDocLE->text());
2442 bp_.master = string();
2445 bp_.clearIncludedChildren();
2446 if (masterChildModule->includeonlyRB->isChecked()) {
2447 list<string>::const_iterator it = includeonlys_.begin();
2448 for (; it != includeonlys_.end() ; ++it) {
2449 bp_.addIncludedChildren(*it);
2452 bp_.maintain_unincluded_children =
2453 masterChildModule->maintainAuxCB->isChecked();
2456 bp_.float_placement = floatModule->get();
2459 // text should have passed validation
2460 bp_.listings_params =
2461 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2464 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2465 outputModule->defaultFormatCO->currentIndex()).toString());
2467 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2468 bp_.useNonTeXFonts = nontexfonts;
2470 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2471 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2473 int mathfmt = outputModule->mathoutCB->currentIndex();
2476 BufferParams::MathOutput const mo =
2477 static_cast<BufferParams::MathOutput>(mathfmt);
2478 bp_.html_math_output = mo;
2479 bp_.html_be_strict = outputModule->strictCB->isChecked();
2480 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2484 fromqstr(fontModule->fontsRomanCO->
2485 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2488 fromqstr(fontModule->fontsSansCO->
2489 itemData(fontModule->fontsSansCO->currentIndex()).toString());
2491 bp_.fonts_typewriter =
2492 fromqstr(fontModule->fontsTypewriterCO->
2493 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2495 if (fontModule->fontencCO->currentIndex() == 0)
2496 bp_.fontenc = "global";
2497 else if (fontModule->fontencCO->currentIndex() == 1)
2498 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2499 else if (fontModule->fontencCO->currentIndex() == 2)
2500 bp_.fontenc = "default";
2503 fromqstr(fontModule->cjkFontLE->text());
2505 bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2507 bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2509 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2511 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2514 bp_.fonts_default_family = "default";
2516 bp_.fonts_default_family = GuiDocument::fontfamilies[
2517 fontModule->fontsDefaultCO->currentIndex()];
2519 if (fontModule->fontsizeCO->currentIndex() == 0)
2520 bp_.fontsize = "default";
2523 fromqstr(fontModule->fontsizeCO->currentText());
2526 bp_.papersize = PAPER_SIZE(
2527 pageLayoutModule->papersizeCO->currentIndex());
2529 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2530 pageLayoutModule->paperwidthUnitCO);
2532 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2533 pageLayoutModule->paperheightUnitCO);
2535 if (pageLayoutModule->facingPagesCB->isChecked())
2536 bp_.sides = TwoSides;
2538 bp_.sides = OneSide;
2540 if (pageLayoutModule->landscapeRB->isChecked())
2541 bp_.orientation = ORIENTATION_LANDSCAPE;
2543 bp_.orientation = ORIENTATION_PORTRAIT;
2546 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2548 Ui::MarginsUi const * m = marginsModule;
2550 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2551 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2552 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2553 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2554 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2555 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2556 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2557 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2560 branchesModule->apply(bp_);
2563 PDFOptions & pdf = bp_.pdfoptions();
2564 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2565 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2566 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2567 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2568 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2570 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2571 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2572 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2573 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2575 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2576 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2577 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2578 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2580 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2581 if (pdfSupportModule->fullscreenCB->isChecked())
2582 pdf.pagemode = pdf.pagemode_fullscreen;
2584 pdf.pagemode.clear();
2585 pdf.quoted_options = pdf.quoted_options_check(
2586 fromqstr(pdfSupportModule->optionsLE->text()));
2590 void GuiDocument::paramsToDialog()
2592 // set the default unit
2593 Length::UNIT const defaultUnit = Length::defaultUnit();
2596 preambleModule->update(bp_, id());
2597 localLayout->update(bp_, id());
2600 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2601 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2604 biblioModule->citeDefaultRB->setChecked(
2605 bp_.citeEngine() == ENGINE_BASIC);
2607 biblioModule->citeNatbibRB->setChecked(
2608 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2609 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2611 biblioModule->citeStyleCO->setCurrentIndex(
2612 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2614 biblioModule->citeJurabibRB->setChecked(
2615 bp_.citeEngine() == ENGINE_JURABIB);
2617 biblioModule->bibtopicCB->setChecked(
2622 split(bp_.bibtex_command, command, ' ');
2624 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2626 biblioModule->bibtexCO->setCurrentIndex(bpos);
2627 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2629 // We reset to default if we do not know the specified compiler
2630 // This is for security reasons
2631 biblioModule->bibtexCO->setCurrentIndex(
2632 biblioModule->bibtexCO->findData(toqstr("default")));
2633 biblioModule->bibtexOptionsED->clear();
2635 biblioModule->bibtexOptionsED->setEnabled(
2636 biblioModule->bibtexCO->currentIndex() != 0);
2639 indicesModule->update(bp_);
2641 // language & quotes
2642 int const pos = langModule->languageCO->findData(toqstr(
2643 bp_.language->lang()));
2644 langModule->languageCO->setCurrentIndex(pos);
2646 langModule->quoteStyleCO->setCurrentIndex(
2647 bp_.quotes_language);
2649 bool default_enc = true;
2650 if (bp_.inputenc != "auto") {
2651 default_enc = false;
2652 if (bp_.inputenc == "default") {
2653 langModule->encodingCO->setCurrentIndex(0);
2656 Encodings::const_iterator it = encodings.begin();
2657 Encodings::const_iterator const end = encodings.end();
2658 for (; it != end; ++it) {
2659 if (it->latexName() == bp_.inputenc) {
2660 enc_gui = it->guiName();
2664 int const i = langModule->encodingCO->findText(
2667 langModule->encodingCO->setCurrentIndex(i);
2669 // unknown encoding. Set to default.
2673 langModule->defaultencodingRB->setChecked(default_enc);
2674 langModule->otherencodingRB->setChecked(!default_enc);
2676 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2678 langModule->languagePackageCO->setCurrentIndex(
2679 langModule->languagePackageCO->findData("custom"));
2680 langModule->languagePackageED->setText(toqstr(bp_.lang_package));
2682 langModule->languagePackageCO->setCurrentIndex(p);
2683 langModule->languagePackageED->clear();
2687 if (bp_.isfontcolor) {
2688 colorModule->fontColorPB->setStyleSheet(
2689 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2691 set_fontcolor = bp_.fontcolor;
2692 is_fontcolor = bp_.isfontcolor;
2694 colorModule->noteFontColorPB->setStyleSheet(
2695 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2696 set_notefontcolor = bp_.notefontcolor;
2698 if (bp_.isbackgroundcolor) {
2699 colorModule->backgroundPB->setStyleSheet(
2700 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2702 set_backgroundcolor = bp_.backgroundcolor;
2703 is_backgroundcolor = bp_.isbackgroundcolor;
2705 colorModule->boxBackgroundPB->setStyleSheet(
2706 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2707 set_boxbgcolor = bp_.boxbgcolor;
2710 int const min_toclevel = documentClass().min_toclevel();
2711 int const max_toclevel = documentClass().max_toclevel();
2712 if (documentClass().hasTocLevels()) {
2713 numberingModule->setEnabled(true);
2714 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2715 numberingModule->depthSL->setMaximum(max_toclevel);
2716 numberingModule->depthSL->setValue(bp_.secnumdepth);
2717 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2718 numberingModule->tocSL->setMaximum(max_toclevel);
2719 numberingModule->tocSL->setValue(bp_.tocdepth);
2722 numberingModule->setEnabled(false);
2723 numberingModule->tocTW->clear();
2727 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2728 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2729 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2730 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2731 bulletsModule->init();
2734 int nitem = findToken(tex_graphics, bp_.graphics_driver);
2736 latexModule->psdriverCO->setCurrentIndex(nitem);
2739 mathsModule->amsCB->setChecked(
2740 bp_.use_amsmath == BufferParams::package_on);
2741 mathsModule->amsautoCB->setChecked(
2742 bp_.use_amsmath == BufferParams::package_auto);
2744 mathsModule->esintCB->setChecked(
2745 bp_.use_esint == BufferParams::package_on);
2746 mathsModule->esintautoCB->setChecked(
2747 bp_.use_esint == BufferParams::package_auto);
2749 mathsModule->mhchemCB->setChecked(
2750 bp_.use_mhchem == BufferParams::package_on);
2751 mathsModule->mhchemautoCB->setChecked(
2752 bp_.use_mhchem == BufferParams::package_auto);
2754 mathsModule->mathdotsCB->setChecked(
2755 bp_.use_mathdots == BufferParams::package_on);
2756 mathsModule->mathdotsautoCB->setChecked(
2757 bp_.use_mathdots == BufferParams::package_auto);
2759 switch (bp_.spacing().getSpace()) {
2760 case Spacing::Other: nitem = 3; break;
2761 case Spacing::Double: nitem = 2; break;
2762 case Spacing::Onehalf: nitem = 1; break;
2763 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2767 string const & layoutID = bp_.baseClassID();
2768 setLayoutComboByIDString(layoutID);
2770 updatePagestyle(documentClass().opt_pagestyle(),
2773 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2774 if (bp_.spacing().getSpace() == Spacing::Other) {
2775 doubleToWidget(textLayoutModule->lspacingLE,
2776 bp_.spacing().getValueAsString());
2780 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2781 textLayoutModule->indentRB->setChecked(true);
2782 string indentation = bp_.getIndentation().asLyXCommand();
2784 if (indentation != "default") {
2785 lengthToWidgets(textLayoutModule->indentLE,
2786 textLayoutModule->indentLengthCO,
2787 indentation, defaultUnit);
2790 textLayoutModule->indentCO->setCurrentIndex(indent);
2793 textLayoutModule->skipRB->setChecked(true);
2795 switch (bp_.getDefSkip().kind()) {
2796 case VSpace::SMALLSKIP:
2799 case VSpace::MEDSKIP:
2802 case VSpace::BIGSKIP:
2805 case VSpace::LENGTH:
2808 string const length = bp_.getDefSkip().asLyXCommand();
2809 lengthToWidgets(textLayoutModule->skipLE,
2810 textLayoutModule->skipLengthCO,
2811 length, defaultUnit);
2818 textLayoutModule->skipCO->setCurrentIndex(skip);
2822 textLayoutModule->twoColumnCB->setChecked(
2825 if (!bp_.options.empty()) {
2826 latexModule->optionsLE->setText(
2827 toqstr(bp_.options));
2829 latexModule->optionsLE->setText(QString());
2833 latexModule->defaultOptionsCB->setChecked(
2834 bp_.use_default_options);
2835 updateSelectedModules();
2836 selectionManager->updateProvidedModules(
2837 bp_.baseClass()->providedModules());
2838 selectionManager->updateExcludedModules(
2839 bp_.baseClass()->excludedModules());
2841 if (!documentClass().options().empty()) {
2842 latexModule->defaultOptionsLE->setText(
2843 toqstr(documentClass().options()));
2845 latexModule->defaultOptionsLE->setText(
2846 toqstr(_("[No options predefined]")));
2849 latexModule->defaultOptionsLE->setEnabled(
2850 bp_.use_default_options
2851 && !documentClass().options().empty());
2853 latexModule->defaultOptionsCB->setEnabled(
2854 !documentClass().options().empty());
2856 if (!bp_.master.empty()) {
2857 latexModule->childDocGB->setChecked(true);
2858 latexModule->childDocLE->setText(
2859 toqstr(bp_.master));
2861 latexModule->childDocLE->setText(QString());
2862 latexModule->childDocGB->setChecked(false);
2866 if (!bufferview() || !buffer().hasChildren()) {
2867 masterChildModule->childrenTW->clear();
2868 includeonlys_.clear();
2869 docPS->showPanel(qt_("Child Documents"), false);
2870 if (docPS->isCurrentPanel(qt_("Child Documents")))
2871 docPS->setCurrentPanel(qt_("Document Class"));
2873 docPS->showPanel(qt_("Child Documents"), true);
2874 masterChildModule->setEnabled(true);
2875 includeonlys_ = bp_.getIncludedChildren();
2876 updateIncludeonlys();
2878 masterChildModule->maintainAuxCB->setChecked(
2879 bp_.maintain_unincluded_children);
2882 floatModule->set(bp_.float_placement);
2885 // break listings_params to multiple lines
2887 InsetListingsParams(bp_.listings_params).separatedParams();
2888 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2891 // update combobox with formats
2892 updateDefaultFormat();
2893 int index = outputModule->defaultFormatCO->findData(toqstr(
2894 bp_.default_output_format));
2895 // set to default if format is not found
2898 outputModule->defaultFormatCO->setCurrentIndex(index);
2899 bool const os_fonts_available =
2900 bp_.baseClass()->outputType() == lyx::LATEX
2901 && LaTeXFeatures::isAvailable("fontspec");
2902 fontModule->osFontsCB->setEnabled(os_fonts_available);
2903 fontModule->osFontsCB->setChecked(
2904 os_fonts_available && bp_.useNonTeXFonts);
2906 outputModule->outputsyncCB->setChecked(bp_.output_sync);
2907 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2909 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2910 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2911 outputModule->strictCB->setChecked(bp_.html_be_strict);
2914 updateFontsize(documentClass().opt_fontsize(),
2917 QString font = toqstr(bp_.fonts_roman);
2918 int rpos = fontModule->fontsRomanCO->findData(font);
2920 rpos = fontModule->fontsRomanCO->count();
2921 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
2923 fontModule->fontsRomanCO->setCurrentIndex(rpos);
2925 font = toqstr(bp_.fonts_sans);
2926 int spos = fontModule->fontsSansCO->findData(font);
2928 spos = fontModule->fontsSansCO->count();
2929 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
2931 fontModule->fontsSansCO->setCurrentIndex(spos);
2933 font = toqstr(bp_.fonts_typewriter);
2934 int tpos = fontModule->fontsTypewriterCO->findData(font);
2936 tpos = fontModule->fontsTypewriterCO->count();
2937 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
2939 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
2941 if (bp_.useNonTeXFonts && os_fonts_available) {
2942 fontModule->fontencLA->setEnabled(false);
2943 fontModule->fontencCO->setEnabled(false);
2944 fontModule->fontencLE->setEnabled(false);
2946 fontModule->fontencLA->setEnabled(true);
2947 fontModule->fontencCO->setEnabled(true);
2948 fontModule->fontencLE->setEnabled(true);
2954 if (!bp_.fonts_cjk.empty())
2955 fontModule->cjkFontLE->setText(
2956 toqstr(bp_.fonts_cjk));
2958 fontModule->cjkFontLE->setText(QString());
2960 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
2961 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
2962 fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
2963 fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
2965 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
2967 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2969 if (bp_.fontenc == "global") {
2970 fontModule->fontencCO->setCurrentIndex(0);
2971 fontModule->fontencLE->setEnabled(false);
2972 } else if (bp_.fontenc == "default") {
2973 fontModule->fontencCO->setCurrentIndex(2);
2974 fontModule->fontencLE->setEnabled(false);
2976 fontModule->fontencCO->setCurrentIndex(1);
2977 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2981 bool const extern_geometry =
2982 documentClass().provides("geometry");
2983 int const psize = bp_.papersize;
2984 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2985 setCustomPapersize(!extern_geometry && psize == 1);
2986 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2988 bool const landscape =
2989 bp_.orientation == ORIENTATION_LANDSCAPE;
2990 pageLayoutModule->landscapeRB->setChecked(landscape);
2991 pageLayoutModule->portraitRB->setChecked(!landscape);
2992 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2993 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2995 pageLayoutModule->facingPagesCB->setChecked(
2996 bp_.sides == TwoSides);
2998 lengthToWidgets(pageLayoutModule->paperwidthLE,
2999 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
3000 lengthToWidgets(pageLayoutModule->paperheightLE,
3001 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
3004 Ui::MarginsUi * m = marginsModule;
3008 lengthToWidgets(m->topLE, m->topUnit,
3009 bp_.topmargin, defaultUnit);
3011 lengthToWidgets(m->bottomLE, m->bottomUnit,
3012 bp_.bottommargin, defaultUnit);
3014 lengthToWidgets(m->innerLE, m->innerUnit,
3015 bp_.leftmargin, defaultUnit);
3017 lengthToWidgets(m->outerLE, m->outerUnit,
3018 bp_.rightmargin, defaultUnit);
3020 lengthToWidgets(m->headheightLE, m->headheightUnit,
3021 bp_.headheight, defaultUnit);
3023 lengthToWidgets(m->headsepLE, m->headsepUnit,
3024 bp_.headsep, defaultUnit);
3026 lengthToWidgets(m->footskipLE, m->footskipUnit,
3027 bp_.footskip, defaultUnit);
3029 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3030 bp_.columnsep, defaultUnit);
3033 updateUnknownBranches();
3034 branchesModule->update(bp_);
3037 PDFOptions const & pdf = bp_.pdfoptions();
3038 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3039 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3040 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3041 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3042 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3044 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3045 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3046 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3048 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3050 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3051 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3052 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3053 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3055 nn = findToken(backref_opts, pdf.backref);
3057 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3059 pdfSupportModule->fullscreenCB->setChecked
3060 (pdf.pagemode == pdf.pagemode_fullscreen);
3062 pdfSupportModule->optionsLE->setText(
3063 toqstr(pdf.quoted_options));
3065 // Make sure that the bc is in the INITIAL state
3066 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3069 // clear changed branches cache
3070 changedBranches_.clear();
3074 void GuiDocument::saveDocDefault()
3076 // we have to apply the params first
3082 void GuiDocument::updateAvailableModules()
3084 modules_av_model_.clear();
3085 list<modInfoStruct> const & modInfoList = getModuleInfo();
3086 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3087 list<modInfoStruct>::const_iterator men = modInfoList.end();
3088 for (int i = 0; mit != men; ++mit, ++i)
3089 modules_av_model_.insertRow(i, mit->name, mit->id,
3094 void GuiDocument::updateSelectedModules()
3096 modules_sel_model_.clear();
3097 list<modInfoStruct> const selModList = getSelectedModules();
3098 list<modInfoStruct>::const_iterator mit = selModList.begin();
3099 list<modInfoStruct>::const_iterator men = selModList.end();
3100 for (int i = 0; mit != men; ++mit, ++i)
3101 modules_sel_model_.insertRow(i, mit->name, mit->id,
3106 void GuiDocument::updateIncludeonlys()
3108 masterChildModule->childrenTW->clear();
3109 QString const no = qt_("No");
3110 QString const yes = qt_("Yes");
3112 if (includeonlys_.empty()) {
3113 masterChildModule->includeallRB->setChecked(true);
3114 masterChildModule->childrenTW->setEnabled(false);
3115 masterChildModule->maintainAuxCB->setEnabled(false);
3117 masterChildModule->includeonlyRB->setChecked(true);
3118 masterChildModule->childrenTW->setEnabled(true);
3119 masterChildModule->maintainAuxCB->setEnabled(true);
3121 QTreeWidgetItem * item = 0;
3122 ListOfBuffers children = buffer().getChildren();
3123 ListOfBuffers::const_iterator it = children.begin();
3124 ListOfBuffers::const_iterator end = children.end();
3125 bool has_unincluded = false;
3126 bool all_unincluded = true;
3127 for (; it != end; ++it) {
3128 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3131 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3132 from_utf8(buffer().filePath())));
3133 item->setText(0, toqstr(name));
3134 item->setText(1, isChildIncluded(name) ? yes : no);
3135 if (!isChildIncluded(name))
3136 has_unincluded = true;
3138 all_unincluded = false;
3140 // Both if all childs are included and if none is included
3141 // is equal to "include all" (i.e., ommit \includeonly).
3142 // Thus, reset the GUI.
3143 if (!has_unincluded || all_unincluded) {
3144 masterChildModule->includeallRB->setChecked(true);
3145 masterChildModule->childrenTW->setEnabled(false);
3146 includeonlys_.clear();
3148 // If all are included, we need to update again.
3149 if (!has_unincluded)
3150 updateIncludeonlys();
3154 void GuiDocument::updateContents()
3156 // Nothing to do here as the document settings is not cursor dependant.
3161 void GuiDocument::useClassDefaults()
3163 if (applyPB->isEnabled()) {
3164 int const ret = Alert::prompt(_("Unapplied changes"),
3165 _("Some changes in the dialog were not yet applied.\n"
3166 "If you do not apply now, they will be lost after this action."),
3167 1, 1, _("&Apply"), _("&Dismiss"));
3172 int idx = latexModule->classCO->currentIndex();
3173 string const classname = classes_model_.getIDString(idx);
3174 if (!bp_.setBaseClass(classname)) {
3175 Alert::error(_("Error"), _("Unable to set document class."));
3178 bp_.useClassDefaults();
3183 void GuiDocument::setLayoutComboByIDString(string const & idString)
3185 int idx = classes_model_.findIDString(idString);
3187 Alert::warning(_("Can't set layout!"),
3188 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3190 latexModule->classCO->setCurrentIndex(idx);
3194 bool GuiDocument::isValid()
3197 validateListingsParameters().isEmpty() &&
3198 localLayout->isValid() &&
3200 // if we're asking for skips between paragraphs
3201 !textLayoutModule->skipRB->isChecked() ||
3202 // then either we haven't chosen custom
3203 textLayoutModule->skipCO->currentIndex() != 3 ||
3204 // or else a length has been given
3205 !textLayoutModule->skipLE->text().isEmpty()
3208 // if we're asking for indentation
3209 !textLayoutModule->indentRB->isChecked() ||
3210 // then either we haven't chosen custom
3211 textLayoutModule->indentCO->currentIndex() != 1 ||
3212 // or else a length has been given
3213 !textLayoutModule->indentLE->text().isEmpty()
3218 char const * const GuiDocument::fontfamilies[5] = {
3219 "default", "rmdefault", "sfdefault", "ttdefault", ""
3223 char const * GuiDocument::fontfamilies_gui[5] = {
3224 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3228 bool GuiDocument::initialiseParams(string const &)
3230 BufferView const * view = bufferview();
3232 bp_ = BufferParams();
3236 bp_ = view->buffer().params();
3238 updateAvailableModules();
3239 //FIXME It'd be nice to make sure here that the selected
3240 //modules are consistent: That required modules are actually
3241 //selected, and that we don't have conflicts. If so, we could
3242 //at least pop up a warning.
3248 void GuiDocument::clearParams()
3250 bp_ = BufferParams();
3254 BufferId GuiDocument::id() const
3256 BufferView const * const view = bufferview();
3257 return view? &view->buffer() : 0;
3261 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3263 return moduleNames_;
3267 list<GuiDocument::modInfoStruct> const
3268 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3270 LayoutModuleList::const_iterator it = mods.begin();
3271 LayoutModuleList::const_iterator end = mods.end();
3272 list<modInfoStruct> mInfo;
3273 for (; it != end; ++it) {
3276 LyXModule const * const mod = theModuleList[*it];
3279 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3281 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3288 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3290 return makeModuleInfo(params().getModules());
3294 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3296 return makeModuleInfo(params().baseClass()->providedModules());
3300 DocumentClass const & GuiDocument::documentClass() const
3302 return bp_.documentClass();
3306 static void dispatch_bufferparams(Dialog const & dialog,
3307 BufferParams const & bp, FuncCode lfun)
3310 ss << "\\begin_header\n";
3312 ss << "\\end_header\n";
3313 dialog.dispatch(FuncRequest(lfun, ss.str()));
3317 void GuiDocument::dispatchParams()
3319 // This must come first so that a language change is correctly noticed
3322 // Apply the BufferParams. Note that this will set the base class
3323 // and then update the buffer's layout.
3324 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3326 if (!params().master.empty()) {
3327 FileName const master_file = support::makeAbsPath(params().master,
3328 support::onlyPath(buffer().absFileName()));
3329 if (isLyXFileName(master_file.absFileName())) {
3330 Buffer * master = checkAndLoadLyXFile(master_file);
3332 if (master->isChild(const_cast<Buffer *>(&buffer())))
3333 const_cast<Buffer &>(buffer()).setParent(master);
3335 Alert::warning(_("Assigned master does not include this file"),
3336 bformat(_("You must include this file in the document\n"
3337 "'%1$s' in order to use the master document\n"
3338 "feature."), from_utf8(params().master)));
3340 Alert::warning(_("Could not load master"),
3341 bformat(_("The master document '%1$s'\n"
3342 "could not be loaded."),
3343 from_utf8(params().master)));
3347 // Generate the colours requested by each new branch.
3348 BranchList & branchlist = params().branchlist();
3349 if (!branchlist.empty()) {
3350 BranchList::const_iterator it = branchlist.begin();
3351 BranchList::const_iterator const end = branchlist.end();
3352 for (; it != end; ++it) {
3353 docstring const & current_branch = it->branch();
3354 Branch const * branch = branchlist.find(current_branch);
3355 string const x11hexname = X11hexname(branch->color());
3356 // display the new color
3357 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3358 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3361 // Open insets of selected branches, close deselected ones
3362 dispatch(FuncRequest(LFUN_INSET_FORALL,
3363 "Branch inset-toggle assign"));
3365 // rename branches in the document
3366 executeBranchRenaming();
3367 // and clear changed branches cache
3368 changedBranches_.clear();
3370 // Generate the colours requested by indices.
3371 IndicesList & indiceslist = params().indiceslist();
3372 if (!indiceslist.empty()) {
3373 IndicesList::const_iterator it = indiceslist.begin();
3374 IndicesList::const_iterator const end = indiceslist.end();
3375 for (; it != end; ++it) {
3376 docstring const & current_index = it->shortcut();
3377 Index const * index = indiceslist.findShortcut(current_index);
3378 string const x11hexname = X11hexname(index->color());
3379 // display the new color
3380 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3381 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3385 // If we used an LFUN, we would not need these two lines:
3386 BufferView * bv = const_cast<BufferView *>(bufferview());
3387 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3391 void GuiDocument::setLanguage() const
3393 Language const * const newL = bp_.language;
3394 if (buffer().params().language == newL)
3397 string const & lang_name = newL->lang();
3398 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3402 void GuiDocument::saveAsDefault() const
3404 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3408 bool GuiDocument::isFontAvailable(string const & font) const
3410 if (font == "default" || font == "cmr"
3411 || font == "cmss" || font == "cmtt")
3412 // these are standard
3414 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3415 return LaTeXFeatures::isAvailable("lmodern");
3416 if (font == "times" || font == "palatino"
3417 || font == "helvet" || font == "courier")
3418 return LaTeXFeatures::isAvailable("psnfss");
3419 if (font == "cmbr" || font == "cmtl")
3420 return LaTeXFeatures::isAvailable("cmbright");
3421 if (font == "utopia")
3422 return LaTeXFeatures::isAvailable("utopia")
3423 || LaTeXFeatures::isAvailable("fourier");
3424 if (font == "beraserif" || font == "berasans"
3425 || font == "beramono")
3426 return LaTeXFeatures::isAvailable("bera");
3427 return LaTeXFeatures::isAvailable(font);
3431 bool GuiDocument::providesOSF(string const & font) const
3433 if (fontModule->osFontsCB->isChecked())
3434 // FIXME: we should check if the fonts really
3435 // have OSF support. But how?
3438 return isFontAvailable("eco");
3439 if (font == "palatino")
3440 return isFontAvailable("mathpazo");
3445 bool GuiDocument::providesSC(string const & font) const
3447 if (fontModule->osFontsCB->isChecked())
3449 if (font == "palatino")
3450 return isFontAvailable("mathpazo");
3451 if (font == "utopia")
3452 return isFontAvailable("fourier");
3457 bool GuiDocument::providesScale(string const & font) const
3459 if (fontModule->osFontsCB->isChecked())
3461 return font == "helvet" || font == "luximono"
3462 || font == "berasans" || font == "beramono";
3466 void GuiDocument::loadModuleInfo()
3468 moduleNames_.clear();
3469 LyXModuleList::const_iterator it = theModuleList.begin();
3470 LyXModuleList::const_iterator end = theModuleList.end();
3471 for (; it != end; ++it) {
3475 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3476 // this is supposed to give us the first sentence of the description
3479 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3480 int const pos = desc.indexOf(".");
3482 desc.truncate(pos + 1);
3483 m.description = desc;
3484 moduleNames_.push_back(m);
3489 void GuiDocument::updateUnknownBranches()
3493 list<docstring> used_branches;
3494 buffer().getUsedBranches(used_branches);
3495 list<docstring>::const_iterator it = used_branches.begin();
3496 QStringList unknown_branches;
3497 for (; it != used_branches.end() ; ++it) {
3498 if (!buffer().params().branchlist().find(*it))
3499 unknown_branches.append(toqstr(*it));
3501 branchesModule->setUnknownBranches(unknown_branches);
3505 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3507 map<docstring, docstring>::iterator it = changedBranches_.begin();
3508 for (; it != changedBranches_.end() ; ++it) {
3509 if (it->second == oldname) {
3510 // branch has already been renamed
3511 it->second = newname;
3516 changedBranches_[oldname] = newname;
3520 void GuiDocument::executeBranchRenaming() const
3522 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3523 for (; it != changedBranches_.end() ; ++it) {
3524 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3525 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3530 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3533 } // namespace frontend
3536 #include "moc_GuiDocument.cpp"