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()));
713 connect(textLayoutModule->justCB, SIGNAL(clicked()),
714 this, SLOT(change_adaptor()));
716 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
717 textLayoutModule->lspacingLE));
718 textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
719 textLayoutModule->indentLE));
720 textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
721 textLayoutModule->skipLE));
723 textLayoutModule->indentCO->addItem(qt_("Default"));
724 textLayoutModule->indentCO->addItem(qt_("Custom"));
725 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
726 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
727 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
728 textLayoutModule->skipCO->addItem(qt_("Custom"));
729 textLayoutModule->lspacingCO->insertItem(
730 Spacing::Single, qt_("Single"));
731 textLayoutModule->lspacingCO->insertItem(
732 Spacing::Onehalf, qt_("OneHalf"));
733 textLayoutModule->lspacingCO->insertItem(
734 Spacing::Double, qt_("Double"));
735 textLayoutModule->lspacingCO->insertItem(
736 Spacing::Other, qt_("Custom"));
737 // initialize the length validator
738 bc().addCheckedLineEdit(textLayoutModule->indentLE);
739 bc().addCheckedLineEdit(textLayoutModule->skipLE);
742 // master/child handling
743 masterChildModule = new UiWidget<Ui::MasterChildUi>;
745 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
746 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
747 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
748 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
749 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
750 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
751 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
752 this, SLOT(change_adaptor()));
753 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
754 this, SLOT(change_adaptor()));
755 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
756 this, SLOT(change_adaptor()));
757 masterChildModule->childrenTW->setColumnCount(2);
758 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
759 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
760 masterChildModule->childrenTW->resizeColumnToContents(1);
761 masterChildModule->childrenTW->resizeColumnToContents(2);
765 outputModule = new UiWidget<Ui::OutputUi>;
767 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
768 this, SLOT(change_adaptor()));
769 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
770 this, SLOT(change_adaptor()));
771 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
772 this, SLOT(change_adaptor()));
773 connect(outputModule->cssCB, SIGNAL(stateChanged(int)),
774 this, SLOT(change_adaptor()));
775 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
776 this, SLOT(change_adaptor()));
778 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
779 this, SLOT(change_adaptor()));
780 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
781 this, SLOT(change_adaptor()));
782 outputModule->synccustomCB->addItem("");
783 outputModule->synccustomCB->addItem("\\synctex=1");
784 outputModule->synccustomCB->addItem("\\synctex=-1");
785 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
787 outputModule->synccustomCB->setValidator(new NoNewLineValidator(
788 outputModule->synccustomCB));
791 fontModule = new UiWidget<Ui::FontUi>;
792 connect(fontModule->osFontsCB, SIGNAL(clicked()),
793 this, SLOT(change_adaptor()));
794 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
795 this, SLOT(osFontsChanged(bool)));
796 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
797 this, SLOT(change_adaptor()));
798 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
799 this, SLOT(romanChanged(int)));
800 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
801 this, SLOT(change_adaptor()));
802 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
803 this, SLOT(sansChanged(int)));
804 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
805 this, SLOT(change_adaptor()));
806 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
807 this, SLOT(ttChanged(int)));
808 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
809 this, SLOT(change_adaptor()));
810 connect(fontModule->fontencCO, SIGNAL(activated(int)),
811 this, SLOT(change_adaptor()));
812 connect(fontModule->fontencCO, SIGNAL(activated(int)),
813 this, SLOT(fontencChanged(int)));
814 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
815 this, SLOT(change_adaptor()));
816 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
817 this, SLOT(change_adaptor()));
818 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
819 this, SLOT(change_adaptor()));
820 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
821 this, SLOT(change_adaptor()));
822 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
823 this, SLOT(change_adaptor()));
824 connect(fontModule->fontScCB, SIGNAL(clicked()),
825 this, SLOT(change_adaptor()));
826 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
827 this, SLOT(change_adaptor()));
829 fontModule->fontencLE->setValidator(new NoNewLineValidator(
830 fontModule->fontencLE));
831 fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
832 fontModule->cjkFontLE));
836 fontModule->fontsizeCO->addItem(qt_("Default"));
837 fontModule->fontsizeCO->addItem(qt_("10"));
838 fontModule->fontsizeCO->addItem(qt_("11"));
839 fontModule->fontsizeCO->addItem(qt_("12"));
841 fontModule->fontencCO->addItem(qt_("Default"));
842 fontModule->fontencCO->addItem(qt_("Custom"));
843 fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
845 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
846 fontModule->fontsDefaultCO->addItem(
847 qt_(GuiDocument::fontfamilies_gui[n]));
849 if (!LaTeXFeatures::isAvailable("fontspec"))
850 fontModule->osFontsCB->setToolTip(
851 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
852 "You need to install the package \"fontspec\" to use this feature"));
856 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
857 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
858 this, SLOT(papersizeChanged(int)));
859 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
860 this, SLOT(papersizeChanged(int)));
861 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
862 this, SLOT(change_adaptor()));
863 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
864 this, SLOT(change_adaptor()));
865 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
866 this, SLOT(change_adaptor()));
867 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
868 this, SLOT(change_adaptor()));
869 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
870 this, SLOT(change_adaptor()));
871 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
872 this, SLOT(change_adaptor()));
873 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
874 this, SLOT(change_adaptor()));
875 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
876 this, SLOT(change_adaptor()));
877 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
878 this, SLOT(change_adaptor()));
879 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
880 this, SLOT(change_adaptor()));
882 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
883 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
884 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
885 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
886 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
887 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
888 pageLayoutModule->paperheightL);
889 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
890 pageLayoutModule->paperwidthL);
892 QComboBox * cb = pageLayoutModule->papersizeCO;
893 cb->addItem(qt_("Default"));
894 cb->addItem(qt_("Custom"));
895 cb->addItem(qt_("US letter"));
896 cb->addItem(qt_("US legal"));
897 cb->addItem(qt_("US executive"));
898 cb->addItem(qt_("A0"));
899 cb->addItem(qt_("A1"));
900 cb->addItem(qt_("A2"));
901 cb->addItem(qt_("A3"));
902 cb->addItem(qt_("A4"));
903 cb->addItem(qt_("A5"));
904 cb->addItem(qt_("A6"));
905 cb->addItem(qt_("B0"));
906 cb->addItem(qt_("B1"));
907 cb->addItem(qt_("B2"));
908 cb->addItem(qt_("B3"));
909 cb->addItem(qt_("B4"));
910 cb->addItem(qt_("B5"));
911 cb->addItem(qt_("B6"));
912 cb->addItem(qt_("C0"));
913 cb->addItem(qt_("C1"));
914 cb->addItem(qt_("C2"));
915 cb->addItem(qt_("C3"));
916 cb->addItem(qt_("C4"));
917 cb->addItem(qt_("C5"));
918 cb->addItem(qt_("C6"));
919 cb->addItem(qt_("JIS B0"));
920 cb->addItem(qt_("JIS B1"));
921 cb->addItem(qt_("JIS B2"));
922 cb->addItem(qt_("JIS B3"));
923 cb->addItem(qt_("JIS B4"));
924 cb->addItem(qt_("JIS B5"));
925 cb->addItem(qt_("JIS B6"));
926 // remove the %-items from the unit choice
927 pageLayoutModule->paperwidthUnitCO->noPercents();
928 pageLayoutModule->paperheightUnitCO->noPercents();
929 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
930 pageLayoutModule->paperheightLE));
931 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
932 pageLayoutModule->paperwidthLE));
936 marginsModule = new UiWidget<Ui::MarginsUi>;
937 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
938 this, SLOT(setCustomMargins(bool)));
939 connect(marginsModule->marginCB, SIGNAL(clicked()),
940 this, SLOT(change_adaptor()));
941 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
942 this, SLOT(change_adaptor()));
943 connect(marginsModule->topUnit, SIGNAL(activated(int)),
944 this, SLOT(change_adaptor()));
945 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
946 this, SLOT(change_adaptor()));
947 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
948 this, SLOT(change_adaptor()));
949 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
950 this, SLOT(change_adaptor()));
951 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
952 this, SLOT(change_adaptor()));
953 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
954 this, SLOT(change_adaptor()));
955 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
956 this, SLOT(change_adaptor()));
957 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
958 this, SLOT(change_adaptor()));
959 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
960 this, SLOT(change_adaptor()));
961 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
962 this, SLOT(change_adaptor()));
963 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
964 this, SLOT(change_adaptor()));
965 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
966 this, SLOT(change_adaptor()));
967 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
968 this, SLOT(change_adaptor()));
969 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
970 this, SLOT(change_adaptor()));
971 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
972 this, SLOT(change_adaptor()));
973 marginsModule->topLE->setValidator(unsignedLengthValidator(
974 marginsModule->topLE));
975 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
976 marginsModule->bottomLE));
977 marginsModule->innerLE->setValidator(unsignedLengthValidator(
978 marginsModule->innerLE));
979 marginsModule->outerLE->setValidator(unsignedLengthValidator(
980 marginsModule->outerLE));
981 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
982 marginsModule->headsepLE));
983 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
984 marginsModule->headheightLE));
985 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
986 marginsModule->footskipLE));
987 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
988 marginsModule->columnsepLE));
990 bc().addCheckedLineEdit(marginsModule->topLE,
991 marginsModule->topL);
992 bc().addCheckedLineEdit(marginsModule->bottomLE,
993 marginsModule->bottomL);
994 bc().addCheckedLineEdit(marginsModule->innerLE,
995 marginsModule->innerL);
996 bc().addCheckedLineEdit(marginsModule->outerLE,
997 marginsModule->outerL);
998 bc().addCheckedLineEdit(marginsModule->headsepLE,
999 marginsModule->headsepL);
1000 bc().addCheckedLineEdit(marginsModule->headheightLE,
1001 marginsModule->headheightL);
1002 bc().addCheckedLineEdit(marginsModule->footskipLE,
1003 marginsModule->footskipL);
1004 bc().addCheckedLineEdit(marginsModule->columnsepLE,
1005 marginsModule->columnsepL);
1009 langModule = new UiWidget<Ui::LanguageUi>;
1010 connect(langModule->languageCO, SIGNAL(activated(int)),
1011 this, SLOT(change_adaptor()));
1012 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1013 this, SLOT(change_adaptor()));
1014 connect(langModule->otherencodingRB, SIGNAL(clicked()),
1015 this, SLOT(change_adaptor()));
1016 connect(langModule->encodingCO, SIGNAL(activated(int)),
1017 this, SLOT(change_adaptor()));
1018 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1019 this, SLOT(change_adaptor()));
1020 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1021 this, SLOT(change_adaptor()));
1022 connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1023 this, SLOT(change_adaptor()));
1024 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1025 this, SLOT(languagePackageChanged(int)));
1027 langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1028 langModule->languagePackageLE));
1030 QAbstractItemModel * language_model = guiApp->languageModel();
1031 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1032 language_model->sort(0);
1033 langModule->languageCO->setModel(language_model);
1034 langModule->languageCO->setModelColumn(0);
1036 // Always put the default encoding in the first position.
1037 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1038 QStringList encodinglist;
1039 Encodings::const_iterator it = encodings.begin();
1040 Encodings::const_iterator const end = encodings.end();
1041 for (; it != end; ++it)
1042 encodinglist.append(qt_(it->guiName()));
1043 encodinglist.sort();
1044 langModule->encodingCO->addItems(encodinglist);
1046 langModule->quoteStyleCO->addItem(qt_("``text''"));
1047 langModule->quoteStyleCO->addItem(qt_("''text''"));
1048 langModule->quoteStyleCO->addItem(qt_(",,text``"));
1049 langModule->quoteStyleCO->addItem(qt_(",,text''"));
1050 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
1051 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
1053 langModule->languagePackageCO->addItem(
1054 qt_("Default"), toqstr("default"));
1055 langModule->languagePackageCO->addItem(
1056 qt_("Automatic"), toqstr("auto"));
1057 langModule->languagePackageCO->addItem(
1058 qt_("Always Babel"), toqstr("babel"));
1059 langModule->languagePackageCO->addItem(
1060 qt_("Custom"), toqstr("custom"));
1061 langModule->languagePackageCO->addItem(
1062 qt_("None[[language package]]"), toqstr("none"));
1066 colorModule = new UiWidget<Ui::ColorUi>;
1067 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1068 this, SLOT(changeFontColor()));
1069 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1070 this, SLOT(deleteFontColor()));
1071 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1072 this, SLOT(changeNoteFontColor()));
1073 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1074 this, SLOT(deleteNoteFontColor()));
1075 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1076 this, SLOT(changeBackgroundColor()));
1077 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1078 this, SLOT(deleteBackgroundColor()));
1079 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1080 this, SLOT(changeBoxBackgroundColor()));
1081 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1082 this, SLOT(deleteBoxBackgroundColor()));
1086 numberingModule = new UiWidget<Ui::NumberingUi>;
1087 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1088 this, SLOT(change_adaptor()));
1089 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1090 this, SLOT(change_adaptor()));
1091 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1092 this, SLOT(updateNumbering()));
1093 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1094 this, SLOT(updateNumbering()));
1095 numberingModule->tocTW->setColumnCount(3);
1096 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1097 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1098 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1099 numberingModule->tocTW->header()->setResizeMode(QHeaderView::ResizeToContents);
1103 biblioModule = new UiWidget<Ui::BiblioUi>;
1104 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1105 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1106 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1107 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1108 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1109 this, SLOT(change_adaptor()));
1110 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1111 this, SLOT(change_adaptor()));
1112 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1113 this, SLOT(change_adaptor()));
1114 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1115 this, SLOT(change_adaptor()));
1116 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1117 this, SLOT(change_adaptor()));
1118 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1119 this, SLOT(bibtexChanged(int)));
1120 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1121 this, SLOT(change_adaptor()));
1123 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1124 biblioModule->bibtexOptionsLE));
1126 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1127 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1128 biblioModule->citeStyleCO->setCurrentIndex(0);
1130 // NOTE: we do not provide "custom" here for security reasons!
1131 biblioModule->bibtexCO->clear();
1132 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1133 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1134 it != lyxrc.bibtex_alternatives.end(); ++it) {
1135 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1136 biblioModule->bibtexCO->addItem(command, command);
1141 indicesModule = new GuiIndices;
1142 connect(indicesModule, SIGNAL(changed()),
1143 this, SLOT(change_adaptor()));
1147 mathsModule = new UiWidget<Ui::MathsUi>;
1148 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1149 mathsModule->amsCB, SLOT(setDisabled(bool)));
1150 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1151 mathsModule->esintCB, SLOT(setDisabled(bool)));
1152 connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1153 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1154 connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1155 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1156 connect(mathsModule->undertildeautoCB, SIGNAL(toggled(bool)),
1157 mathsModule->undertildeCB, SLOT(setDisabled(bool)));
1159 connect(mathsModule->amsCB, SIGNAL(clicked()),
1160 this, SLOT(change_adaptor()));
1161 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1162 this, SLOT(change_adaptor()));
1163 connect(mathsModule->esintCB, SIGNAL(clicked()),
1164 this, SLOT(change_adaptor()));
1165 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1166 this, SLOT(change_adaptor()));
1167 connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1168 this, SLOT(change_adaptor()));
1169 connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1170 this, SLOT(change_adaptor()));
1171 connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1172 this, SLOT(change_adaptor()));
1173 connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1174 this, SLOT(change_adaptor()));
1175 connect(mathsModule->undertildeCB, SIGNAL(clicked()),
1176 this, SLOT(change_adaptor()));
1177 connect(mathsModule->undertildeautoCB, SIGNAL(clicked()),
1178 this, SLOT(change_adaptor()));
1182 latexModule = new UiWidget<Ui::LaTeXUi>;
1183 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1184 this, SLOT(change_adaptor()));
1185 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1186 this, SLOT(change_adaptor()));
1187 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1188 this, SLOT(change_adaptor()));
1189 connect(latexModule->classCO, SIGNAL(activated(int)),
1190 this, SLOT(classChanged()));
1191 connect(latexModule->classCO, SIGNAL(activated(int)),
1192 this, SLOT(change_adaptor()));
1193 connect(latexModule->layoutPB, SIGNAL(clicked()),
1194 this, SLOT(browseLayout()));
1195 connect(latexModule->layoutPB, SIGNAL(clicked()),
1196 this, SLOT(change_adaptor()));
1197 connect(latexModule->childDocGB, SIGNAL(clicked()),
1198 this, SLOT(change_adaptor()));
1199 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1200 this, SLOT(change_adaptor()));
1201 connect(latexModule->childDocPB, SIGNAL(clicked()),
1202 this, SLOT(browseMaster()));
1203 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1204 this, SLOT(change_adaptor()));
1205 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1206 this, SLOT(change_adaptor()));
1208 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1209 latexModule->optionsLE));
1210 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1211 latexModule->childDocLE));
1213 // postscript drivers
1214 for (int n = 0; tex_graphics[n][0]; ++n) {
1215 QString enc = qt_(tex_graphics_gui[n]);
1216 latexModule->psdriverCO->addItem(enc);
1219 latexModule->classCO->setModel(&classes_model_);
1220 LayoutFileList const & bcl = LayoutFileList::get();
1221 vector<LayoutFileIndex> classList = bcl.classList();
1222 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1224 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1225 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1226 for (int i = 0; cit != cen; ++cit, ++i) {
1227 LayoutFile const & tc = bcl[*cit];
1228 docstring item = (tc.isTeXClassAvailable()) ?
1229 from_utf8(tc.description()) :
1230 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1231 classes_model_.insertRow(i, toqstr(item), *cit);
1236 branchesModule = new GuiBranches;
1237 connect(branchesModule, SIGNAL(changed()),
1238 this, SLOT(change_adaptor()));
1239 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1240 this, SLOT(branchesRename(docstring const &, docstring const &)));
1241 updateUnknownBranches();
1245 preambleModule = new PreambleModule;
1246 connect(preambleModule, SIGNAL(changed()),
1247 this, SLOT(change_adaptor()));
1249 localLayout = new LocalLayout;
1250 connect(localLayout, SIGNAL(changed()),
1251 this, SLOT(change_adaptor()));
1255 bulletsModule = new BulletsModule;
1256 connect(bulletsModule, SIGNAL(changed()),
1257 this, SLOT(change_adaptor()));
1261 modulesModule = new UiWidget<Ui::ModulesUi>;
1262 modulesModule->availableLV->header()->setVisible(false);
1263 modulesModule->availableLV->header()->setResizeMode(QHeaderView::ResizeToContents);
1264 modulesModule->availableLV->header()->setStretchLastSection(false);
1266 new ModuleSelectionManager(modulesModule->availableLV,
1267 modulesModule->selectedLV,
1268 modulesModule->addPB, modulesModule->deletePB,
1269 modulesModule->upPB, modulesModule->downPB,
1270 availableModel(), selectedModel(), this);
1271 connect(selectionManager, SIGNAL(updateHook()),
1272 this, SLOT(updateModuleInfo()));
1273 connect(selectionManager, SIGNAL(updateHook()),
1274 this, SLOT(change_adaptor()));
1275 connect(selectionManager, SIGNAL(selectionChanged()),
1276 this, SLOT(modulesChanged()));
1280 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1281 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1282 this, SLOT(change_adaptor()));
1283 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1284 this, SLOT(change_adaptor()));
1285 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1286 this, SLOT(change_adaptor()));
1287 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1288 this, SLOT(change_adaptor()));
1289 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1290 this, SLOT(change_adaptor()));
1291 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1292 this, SLOT(change_adaptor()));
1293 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1294 this, SLOT(change_adaptor()));
1295 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1296 this, SLOT(change_adaptor()));
1297 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1298 this, SLOT(change_adaptor()));
1299 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1300 this, SLOT(change_adaptor()));
1301 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1302 this, SLOT(change_adaptor()));
1303 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1304 this, SLOT(change_adaptor()));
1305 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1306 this, SLOT(change_adaptor()));
1307 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1308 this, SLOT(change_adaptor()));
1309 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1310 this, SLOT(change_adaptor()));
1311 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1312 this, SLOT(change_adaptor()));
1314 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1315 pdfSupportModule->titleLE));
1316 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1317 pdfSupportModule->authorLE));
1318 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1319 pdfSupportModule->subjectLE));
1320 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1321 pdfSupportModule->keywordsLE));
1322 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1323 pdfSupportModule->optionsLE));
1325 for (int i = 0; backref_opts[i][0]; ++i)
1326 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1330 floatModule = new FloatPlacement;
1331 connect(floatModule, SIGNAL(changed()),
1332 this, SLOT(change_adaptor()));
1336 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1337 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1338 this, SLOT(change_adaptor()));
1339 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1340 this, SLOT(change_adaptor()));
1341 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1342 this, SLOT(setListingsMessage()));
1343 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1344 this, SLOT(setListingsMessage()));
1345 listingsModule->listingsTB->setPlainText(
1346 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1350 docPS->addPanel(latexModule, qt_("Document Class"));
1351 docPS->addPanel(masterChildModule, qt_("Child Documents"));
1352 docPS->addPanel(modulesModule, qt_("Modules"));
1353 docPS->addPanel(localLayout, qt_("Local Layout"));
1354 docPS->addPanel(fontModule, qt_("Fonts"));
1355 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1356 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1357 docPS->addPanel(marginsModule, qt_("Page Margins"));
1358 docPS->addPanel(langModule, qt_("Language"));
1359 docPS->addPanel(colorModule, qt_("Colors"));
1360 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1361 docPS->addPanel(biblioModule, qt_("Bibliography"));
1362 docPS->addPanel(indicesModule, qt_("Indexes"));
1363 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1364 docPS->addPanel(mathsModule, qt_("Math Options"));
1365 docPS->addPanel(floatModule, qt_("Float Placement"));
1366 docPS->addPanel(listingsModule, qt_("Listings"));
1367 docPS->addPanel(bulletsModule, qt_("Bullets"));
1368 docPS->addPanel(branchesModule, qt_("Branches"));
1369 docPS->addPanel(outputModule, qt_("Output"));
1370 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1371 docPS->setCurrentPanel(qt_("Document Class"));
1372 // FIXME: hack to work around resizing bug in Qt >= 4.2
1373 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1374 #if QT_VERSION >= 0x040200
1375 docPS->updateGeometry();
1380 void GuiDocument::saveDefaultClicked()
1386 void GuiDocument::useDefaultsClicked()
1392 void GuiDocument::change_adaptor()
1398 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1403 string child = fromqstr(item->text(0));
1407 if (std::find(includeonlys_.begin(),
1408 includeonlys_.end(), child) != includeonlys_.end())
1409 includeonlys_.remove(child);
1411 includeonlys_.push_back(child);
1413 updateIncludeonlys();
1418 QString GuiDocument::validateListingsParameters()
1420 // use a cache here to avoid repeated validation
1421 // of the same parameters
1422 static string param_cache;
1423 static QString msg_cache;
1425 if (listingsModule->bypassCB->isChecked())
1428 string params = fromqstr(listingsModule->listingsED->toPlainText());
1429 if (params != param_cache) {
1430 param_cache = params;
1431 msg_cache = toqstr(InsetListingsParams(params).validate());
1437 void GuiDocument::setListingsMessage()
1439 static bool isOK = true;
1440 QString msg = validateListingsParameters();
1441 if (msg.isEmpty()) {
1445 // listingsTB->setTextColor("black");
1446 listingsModule->listingsTB->setPlainText(
1447 qt_("Input listings parameters below. "
1448 "Enter ? for a list of parameters."));
1451 // listingsTB->setTextColor("red");
1452 listingsModule->listingsTB->setPlainText(msg);
1457 void GuiDocument::setLSpacing(int item)
1459 textLayoutModule->lspacingLE->setEnabled(item == 3);
1463 void GuiDocument::setIndent(int item)
1465 bool const enable = (item == 1);
1466 textLayoutModule->indentLE->setEnabled(enable);
1467 textLayoutModule->indentLengthCO->setEnabled(enable);
1468 textLayoutModule->skipLE->setEnabled(false);
1469 textLayoutModule->skipLengthCO->setEnabled(false);
1474 void GuiDocument::enableIndent(bool indent)
1476 textLayoutModule->skipLE->setEnabled(!indent);
1477 textLayoutModule->skipLengthCO->setEnabled(!indent);
1479 setIndent(textLayoutModule->indentCO->currentIndex());
1483 void GuiDocument::setSkip(int item)
1485 bool const enable = (item == 3);
1486 textLayoutModule->skipLE->setEnabled(enable);
1487 textLayoutModule->skipLengthCO->setEnabled(enable);
1492 void GuiDocument::enableSkip(bool skip)
1494 textLayoutModule->indentLE->setEnabled(!skip);
1495 textLayoutModule->indentLengthCO->setEnabled(!skip);
1497 setSkip(textLayoutModule->skipCO->currentIndex());
1501 void GuiDocument::setMargins()
1503 bool const extern_geometry =
1504 documentClass().provides("geometry");
1505 marginsModule->marginCB->setEnabled(!extern_geometry);
1506 if (extern_geometry) {
1507 marginsModule->marginCB->setChecked(false);
1508 setCustomMargins(true);
1510 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1511 setCustomMargins(!bp_.use_geometry);
1516 void GuiDocument::papersizeChanged(int paper_size)
1518 setCustomPapersize(paper_size == 1);
1522 void GuiDocument::setCustomPapersize(bool custom)
1524 pageLayoutModule->paperwidthL->setEnabled(custom);
1525 pageLayoutModule->paperwidthLE->setEnabled(custom);
1526 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1527 pageLayoutModule->paperheightL->setEnabled(custom);
1528 pageLayoutModule->paperheightLE->setEnabled(custom);
1529 pageLayoutModule->paperheightLE->setFocus();
1530 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1534 void GuiDocument::setColSep()
1536 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1540 void GuiDocument::setCustomMargins(bool custom)
1542 marginsModule->topL->setEnabled(!custom);
1543 marginsModule->topLE->setEnabled(!custom);
1544 marginsModule->topUnit->setEnabled(!custom);
1546 marginsModule->bottomL->setEnabled(!custom);
1547 marginsModule->bottomLE->setEnabled(!custom);
1548 marginsModule->bottomUnit->setEnabled(!custom);
1550 marginsModule->innerL->setEnabled(!custom);
1551 marginsModule->innerLE->setEnabled(!custom);
1552 marginsModule->innerUnit->setEnabled(!custom);
1554 marginsModule->outerL->setEnabled(!custom);
1555 marginsModule->outerLE->setEnabled(!custom);
1556 marginsModule->outerUnit->setEnabled(!custom);
1558 marginsModule->headheightL->setEnabled(!custom);
1559 marginsModule->headheightLE->setEnabled(!custom);
1560 marginsModule->headheightUnit->setEnabled(!custom);
1562 marginsModule->headsepL->setEnabled(!custom);
1563 marginsModule->headsepLE->setEnabled(!custom);
1564 marginsModule->headsepUnit->setEnabled(!custom);
1566 marginsModule->footskipL->setEnabled(!custom);
1567 marginsModule->footskipLE->setEnabled(!custom);
1568 marginsModule->footskipUnit->setEnabled(!custom);
1570 bool const enableColSep = !custom &&
1571 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1572 marginsModule->columnsepL->setEnabled(enableColSep);
1573 marginsModule->columnsepLE->setEnabled(enableColSep);
1574 marginsModule->columnsepUnit->setEnabled(enableColSep);
1578 void GuiDocument::changeBackgroundColor()
1580 QColor const & newColor = QColorDialog::getColor(
1581 rgb2qcolor(set_backgroundcolor), asQWidget());
1582 if (!newColor.isValid())
1584 // set the button color and text
1585 colorModule->backgroundPB->setStyleSheet(
1586 colorButtonStyleSheet(newColor));
1587 colorModule->backgroundPB->setText(qt_("&Change..."));
1589 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1590 is_backgroundcolor = true;
1595 void GuiDocument::deleteBackgroundColor()
1597 // set the button color back to default by setting an empty StyleSheet
1598 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1599 // change button text
1600 colorModule->backgroundPB->setText(qt_("&Default..."));
1601 // save default color (white)
1602 set_backgroundcolor = rgbFromHexName("#ffffff");
1603 is_backgroundcolor = false;
1608 void GuiDocument::changeFontColor()
1610 QColor const & newColor = QColorDialog::getColor(
1611 rgb2qcolor(set_fontcolor), asQWidget());
1612 if (!newColor.isValid())
1614 // set the button color and text
1615 colorModule->fontColorPB->setStyleSheet(
1616 colorButtonStyleSheet(newColor));
1617 colorModule->fontColorPB->setText(qt_("&Change..."));
1619 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1620 is_fontcolor = true;
1625 void GuiDocument::deleteFontColor()
1627 // set the button color back to default by setting an empty StyleSheet
1628 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1629 // change button text
1630 colorModule->fontColorPB->setText(qt_("&Default..."));
1631 // save default color (black)
1632 set_fontcolor = rgbFromHexName("#000000");
1633 is_fontcolor = false;
1638 void GuiDocument::changeNoteFontColor()
1640 QColor const & newColor = QColorDialog::getColor(
1641 rgb2qcolor(set_notefontcolor), asQWidget());
1642 if (!newColor.isValid())
1644 // set the button color
1645 colorModule->noteFontColorPB->setStyleSheet(
1646 colorButtonStyleSheet(newColor));
1648 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1653 void GuiDocument::deleteNoteFontColor()
1655 // set the button color back to pref
1656 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1657 colorModule->noteFontColorPB->setStyleSheet(
1658 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1663 void GuiDocument::changeBoxBackgroundColor()
1665 QColor const & newColor = QColorDialog::getColor(
1666 rgb2qcolor(set_boxbgcolor), asQWidget());
1667 if (!newColor.isValid())
1669 // set the button color
1670 colorModule->boxBackgroundPB->setStyleSheet(
1671 colorButtonStyleSheet(newColor));
1673 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1678 void GuiDocument::deleteBoxBackgroundColor()
1680 // set the button color back to pref
1681 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1682 colorModule->boxBackgroundPB->setStyleSheet(
1683 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1688 void GuiDocument::osFontsChanged(bool nontexfonts)
1690 bool const tex_fonts = !nontexfonts;
1692 updateDefaultFormat();
1693 langModule->encodingCO->setEnabled(tex_fonts &&
1694 !langModule->defaultencodingRB->isChecked());
1695 langModule->defaultencodingRB->setEnabled(tex_fonts);
1696 langModule->otherencodingRB->setEnabled(tex_fonts);
1698 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1699 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1700 fontModule->cjkFontLE->setEnabled(tex_fonts);
1701 fontModule->cjkFontLA->setEnabled(tex_fonts);
1704 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1705 bool scaleable = providesScale(font);
1706 fontModule->scaleSansSB->setEnabled(scaleable);
1707 fontModule->scaleSansLA->setEnabled(scaleable);
1709 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1710 scaleable = providesScale(font);
1711 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1712 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1714 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1715 fontModule->fontScCB->setEnabled(providesSC(font));
1716 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1718 fontModule->fontencLA->setEnabled(tex_fonts);
1719 fontModule->fontencCO->setEnabled(tex_fonts);
1721 fontModule->fontencLE->setEnabled(false);
1723 fontencChanged(fontModule->fontencCO->currentIndex());
1727 void GuiDocument::updateFontsize(string const & items, string const & sel)
1729 fontModule->fontsizeCO->clear();
1730 fontModule->fontsizeCO->addItem(qt_("Default"));
1732 for (int n = 0; !token(items,'|',n).empty(); ++n)
1733 fontModule->fontsizeCO->
1734 addItem(toqstr(token(items,'|',n)));
1736 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1737 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1738 fontModule->fontsizeCO->setCurrentIndex(n);
1745 void GuiDocument::updateFontlist()
1747 fontModule->fontsRomanCO->clear();
1748 fontModule->fontsSansCO->clear();
1749 fontModule->fontsTypewriterCO->clear();
1751 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1752 if (fontModule->osFontsCB->isChecked()) {
1753 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1754 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1755 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1757 QFontDatabase fontdb;
1758 QStringList families(fontdb.families());
1759 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1760 fontModule->fontsRomanCO->addItem(*it, *it);
1761 fontModule->fontsSansCO->addItem(*it, *it);
1762 fontModule->fontsTypewriterCO->addItem(*it, *it);
1767 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1768 QString font = qt_(tex_fonts_roman_gui[n]);
1769 if (!isFontAvailable(tex_fonts_roman[n]))
1770 font += qt_(" (not installed)");
1771 fontModule->fontsRomanCO->addItem(font, qt_(tex_fonts_roman[n]));
1773 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1774 QString font = qt_(tex_fonts_sans_gui[n]);
1775 if (!isFontAvailable(tex_fonts_sans[n]))
1776 font += qt_(" (not installed)");
1777 fontModule->fontsSansCO->addItem(font, qt_(tex_fonts_sans[n]));
1779 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1780 QString font = qt_(tex_fonts_monospaced_gui[n]);
1781 if (!isFontAvailable(tex_fonts_monospaced[n]))
1782 font += qt_(" (not installed)");
1783 fontModule->fontsTypewriterCO->addItem(font, qt_(tex_fonts_monospaced[n]));
1788 void GuiDocument::fontencChanged(int item)
1790 fontModule->fontencLE->setEnabled(item == 1);
1794 void GuiDocument::romanChanged(int item)
1796 if (fontModule->osFontsCB->isChecked())
1798 string const font = tex_fonts_roman[item];
1799 fontModule->fontScCB->setEnabled(providesSC(font));
1800 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1804 void GuiDocument::sansChanged(int item)
1806 if (fontModule->osFontsCB->isChecked())
1808 string const font = tex_fonts_sans[item];
1809 bool scaleable = providesScale(font);
1810 fontModule->scaleSansSB->setEnabled(scaleable);
1811 fontModule->scaleSansLA->setEnabled(scaleable);
1815 void GuiDocument::ttChanged(int item)
1817 if (fontModule->osFontsCB->isChecked())
1819 string const font = tex_fonts_monospaced[item];
1820 bool scaleable = providesScale(font);
1821 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1822 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1826 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1829 pageLayoutModule->pagestyleCO->clear();
1830 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1832 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1833 string style = token(items, '|', n);
1834 QString style_gui = qt_(style);
1835 pagestyles.push_back(pair<string, QString>(style, style_gui));
1836 pageLayoutModule->pagestyleCO->addItem(style_gui);
1839 if (sel == "default") {
1840 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1846 for (size_t i = 0; i < pagestyles.size(); ++i)
1847 if (pagestyles[i].first == sel)
1848 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1851 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1855 void GuiDocument::browseLayout()
1857 QString const label1 = qt_("Layouts|#o#O");
1858 QString const dir1 = toqstr(lyxrc.document_path);
1859 QStringList const filter(qt_("LyX Layout (*.layout)"));
1860 QString file = browseRelToParent(QString(), bufferFilePath(),
1861 qt_("Local layout file"), filter, false,
1864 if (!file.endsWith(".layout"))
1867 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1868 fromqstr(bufferFilePath()));
1870 int const ret = Alert::prompt(_("Local layout file"),
1871 _("The layout file you have selected is a local layout\n"
1872 "file, not one in the system or user directory. Your\n"
1873 "document may not work with this layout if you do not\n"
1874 "keep the layout file in the document directory."),
1875 1, 1, _("&Set Layout"), _("&Cancel"));
1879 // load the layout file
1880 LayoutFileList & bcl = LayoutFileList::get();
1881 string classname = layoutFile.onlyFileName();
1882 // this will update an existing layout if that layout has been loaded before.
1883 LayoutFileIndex name = bcl.addLocalLayout(
1884 classname.substr(0, classname.size() - 7),
1885 layoutFile.onlyPath().absFileName());
1888 Alert::error(_("Error"),
1889 _("Unable to read local layout file."));
1893 // do not trigger classChanged if there is no change.
1894 if (latexModule->classCO->currentText() == toqstr(name))
1898 int idx = latexModule->classCO->findText(toqstr(name));
1900 classes_model_.insertRow(0, toqstr(name), name);
1901 latexModule->classCO->setCurrentIndex(0);
1903 latexModule->classCO->setCurrentIndex(idx);
1909 void GuiDocument::browseMaster()
1911 QString const title = qt_("Select master document");
1912 QString const dir1 = toqstr(lyxrc.document_path);
1913 QString const old = latexModule->childDocLE->text();
1914 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1915 QStringList const filter(qt_("LyX Files (*.lyx)"));
1916 QString file = browseRelToSub(old, docpath, title, filter, false,
1917 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1919 if (!file.isEmpty())
1920 latexModule->childDocLE->setText(file);
1924 void GuiDocument::classChanged()
1926 int idx = latexModule->classCO->currentIndex();
1929 string const classname = classes_model_.getIDString(idx);
1931 // check whether the selected modules have changed.
1932 bool modules_changed = false;
1933 unsigned int const srows = selectedModel()->rowCount();
1934 if (srows != bp_.getModules().size())
1935 modules_changed = true;
1937 list<string>::const_iterator mit = bp_.getModules().begin();
1938 list<string>::const_iterator men = bp_.getModules().end();
1939 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1940 if (selectedModel()->getIDString(i) != *mit) {
1941 modules_changed = true;
1946 if (modules_changed || lyxrc.auto_reset_options) {
1947 if (applyPB->isEnabled()) {
1948 int const ret = Alert::prompt(_("Unapplied changes"),
1949 _("Some changes in the dialog were not yet applied.\n"
1950 "If you do not apply now, they will be lost after this action."),
1951 1, 1, _("&Apply"), _("&Dismiss"));
1957 // We load the TextClass as soon as it is selected. This is
1958 // necessary so that other options in the dialog can be updated
1959 // according to the new class. Note, however, that, if you use
1960 // the scroll wheel when sitting on the combo box, we'll load a
1961 // lot of TextClass objects very quickly....
1962 if (!bp_.setBaseClass(classname)) {
1963 Alert::error(_("Error"), _("Unable to set document class."));
1966 if (lyxrc.auto_reset_options)
1967 bp_.useClassDefaults();
1969 // With the introduction of modules came a distinction between the base
1970 // class and the document class. The former corresponds to the main layout
1971 // file; the latter is that plus the modules (or the document-specific layout,
1972 // or whatever else there could be). Our parameters come from the document
1973 // class. So when we set the base class, we also need to recreate the document
1974 // class. Otherwise, we still have the old one.
1975 bp_.makeDocumentClass();
1980 void GuiDocument::languagePackageChanged(int i)
1982 langModule->languagePackageLE->setEnabled(
1983 langModule->languagePackageCO->itemData(i).toString() == "custom");
1987 void GuiDocument::bibtexChanged(int n)
1989 biblioModule->bibtexOptionsLE->setEnabled(
1990 biblioModule->bibtexCO->itemData(n).toString() != "default");
1997 // both of these should take a vector<docstring>
1999 // This is an insanely complicated attempt to make this sort of thing
2000 // work with RTL languages.
2001 docstring formatStrVec(vector<string> const & v, docstring const & s)
2003 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2007 return translateIfPossible(from_utf8(v[0]));
2008 if (v.size() == 2) {
2009 docstring retval = _("%1$s and %2$s");
2010 retval = subst(retval, _("and"), s);
2011 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2012 translateIfPossible(from_utf8(v[1])));
2014 // The idea here is to format all but the last two items...
2015 int const vSize = v.size();
2016 docstring t2 = _("%1$s, %2$s");
2017 docstring retval = translateIfPossible(from_utf8(v[0]));
2018 for (int i = 1; i < vSize - 2; ++i)
2019 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2020 //...and then to plug them, and the last two, into this schema
2021 docstring t = _("%1$s, %2$s, and %3$s");
2022 t = subst(t, _("and"), s);
2023 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2024 translateIfPossible(from_utf8(v[vSize - 1])));
2027 vector<string> idsToNames(vector<string> const & idList)
2029 vector<string> retval;
2030 vector<string>::const_iterator it = idList.begin();
2031 vector<string>::const_iterator end = idList.end();
2032 for (; it != end; ++it) {
2033 LyXModule const * const mod = theModuleList[*it];
2035 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2036 translateIfPossible(from_utf8(*it)))));
2038 retval.push_back(mod->getName());
2042 } // end anonymous namespace
2045 void GuiDocument::modulesToParams(BufferParams & bp)
2047 // update list of loaded modules
2048 bp.clearLayoutModules();
2049 int const srows = modules_sel_model_.rowCount();
2050 for (int i = 0; i < srows; ++i)
2051 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2053 // update the list of removed modules
2054 bp.clearRemovedModules();
2055 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2056 list<string>::const_iterator rit = reqmods.begin();
2057 list<string>::const_iterator ren = reqmods.end();
2059 // check each of the default modules
2060 for (; rit != ren; rit++) {
2061 list<string>::const_iterator mit = bp.getModules().begin();
2062 list<string>::const_iterator men = bp.getModules().end();
2064 for (; mit != men; mit++) {
2071 // the module isn't present so must have been removed by the user
2072 bp.addRemovedModule(*rit);
2077 void GuiDocument::modulesChanged()
2079 modulesToParams(bp_);
2080 bp_.makeDocumentClass();
2085 void GuiDocument::updateModuleInfo()
2087 selectionManager->update();
2089 //Module description
2090 bool const focus_on_selected = selectionManager->selectedFocused();
2091 QAbstractItemView * lv;
2092 if (focus_on_selected)
2093 lv = modulesModule->selectedLV;
2095 lv= modulesModule->availableLV;
2096 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2097 modulesModule->infoML->document()->clear();
2100 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2101 GuiIdListModel const & id_model =
2102 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2103 string const modName = id_model.getIDString(idx.row());
2104 docstring desc = getModuleDescription(modName);
2106 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2107 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2110 desc += _("Module provided by document class.");
2113 vector<string> pkglist = getPackageList(modName);
2114 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2115 if (!pkgdesc.empty()) {
2118 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2121 pkglist = getRequiredList(modName);
2122 if (!pkglist.empty()) {
2123 vector<string> const reqdescs = idsToNames(pkglist);
2124 pkgdesc = formatStrVec(reqdescs, _("or"));
2127 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2130 pkglist = getExcludedList(modName);
2131 if (!pkglist.empty()) {
2132 vector<string> const reqdescs = idsToNames(pkglist);
2133 pkgdesc = formatStrVec(reqdescs, _( "and"));
2136 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2139 if (!isModuleAvailable(modName)) {
2142 desc += _("WARNING: Some required packages are unavailable!");
2145 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2149 void GuiDocument::updateNumbering()
2151 DocumentClass const & tclass = documentClass();
2153 numberingModule->tocTW->setUpdatesEnabled(false);
2154 numberingModule->tocTW->clear();
2156 int const depth = numberingModule->depthSL->value();
2157 int const toc = numberingModule->tocSL->value();
2158 QString const no = qt_("No");
2159 QString const yes = qt_("Yes");
2160 QTreeWidgetItem * item = 0;
2162 DocumentClass::const_iterator lit = tclass.begin();
2163 DocumentClass::const_iterator len = tclass.end();
2164 for (; lit != len; ++lit) {
2165 int const toclevel = lit->toclevel;
2166 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2167 item = new QTreeWidgetItem(numberingModule->tocTW);
2168 item->setText(0, toqstr(translateIfPossible(lit->name())));
2169 item->setText(1, (toclevel <= depth) ? yes : no);
2170 item->setText(2, (toclevel <= toc) ? yes : no);
2174 numberingModule->tocTW->setUpdatesEnabled(true);
2175 numberingModule->tocTW->update();
2179 void GuiDocument::updateDefaultFormat()
2183 // make a copy in order to consider unapplied changes
2184 BufferParams param_copy = buffer().params();
2185 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2186 int const idx = latexModule->classCO->currentIndex();
2188 string const classname = classes_model_.getIDString(idx);
2189 param_copy.setBaseClass(classname);
2190 param_copy.makeDocumentClass();
2192 outputModule->defaultFormatCO->blockSignals(true);
2193 outputModule->defaultFormatCO->clear();
2194 outputModule->defaultFormatCO->addItem(qt_("Default"),
2195 QVariant(QString("default")));
2196 typedef vector<Format const *> Formats;
2197 Formats formats = param_copy.exportableFormats(true);
2198 Formats::const_iterator cit = formats.begin();
2199 Formats::const_iterator end = formats.end();
2200 for (; cit != end; ++cit)
2201 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2202 QVariant(toqstr((*cit)->name())));
2203 outputModule->defaultFormatCO->blockSignals(false);
2207 bool GuiDocument::isChildIncluded(string const & child)
2209 if (includeonlys_.empty())
2211 return (std::find(includeonlys_.begin(),
2212 includeonlys_.end(), child) != includeonlys_.end());
2216 void GuiDocument::applyView()
2219 preambleModule->apply(bp_);
2220 localLayout->apply(bp_);
2223 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2224 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2227 bp_.setCiteEngine(ENGINE_BASIC);
2229 if (biblioModule->citeNatbibRB->isChecked()) {
2230 bool const use_numerical_citations =
2231 biblioModule->citeStyleCO->currentIndex();
2232 if (use_numerical_citations)
2233 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2235 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2237 } else if (biblioModule->citeJurabibRB->isChecked())
2238 bp_.setCiteEngine(ENGINE_JURABIB);
2241 biblioModule->bibtopicCB->isChecked();
2243 string const bibtex_command =
2244 fromqstr(biblioModule->bibtexCO->itemData(
2245 biblioModule->bibtexCO->currentIndex()).toString());
2246 string const bibtex_options =
2247 fromqstr(biblioModule->bibtexOptionsLE->text());
2248 if (bibtex_command == "default" || bibtex_options.empty())
2249 bp_.bibtex_command = bibtex_command;
2251 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2253 buffer().removeBiblioTempFiles();
2256 indicesModule->apply(bp_);
2258 // language & quotes
2259 if (langModule->defaultencodingRB->isChecked()) {
2260 bp_.inputenc = "auto";
2262 int i = langModule->encodingCO->currentIndex();
2264 bp_.inputenc = "default";
2266 QString const enc_gui =
2267 langModule->encodingCO->currentText();
2268 Encodings::const_iterator it = encodings.begin();
2269 Encodings::const_iterator const end = encodings.end();
2271 for (; it != end; ++it) {
2272 if (qt_(it->guiName()) == enc_gui) {
2273 bp_.inputenc = it->latexName();
2279 // should not happen
2280 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2281 bp_.inputenc = "default";
2286 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2287 switch (langModule->quoteStyleCO->currentIndex()) {
2289 lga = InsetQuotes::EnglishQuotes;
2292 lga = InsetQuotes::SwedishQuotes;
2295 lga = InsetQuotes::GermanQuotes;
2298 lga = InsetQuotes::PolishQuotes;
2301 lga = InsetQuotes::FrenchQuotes;
2304 lga = InsetQuotes::DanishQuotes;
2307 bp_.quotes_language = lga;
2309 QString const lang = langModule->languageCO->itemData(
2310 langModule->languageCO->currentIndex()).toString();
2311 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2313 QString const pack = langModule->languagePackageCO->itemData(
2314 langModule->languagePackageCO->currentIndex()).toString();
2315 if (pack == "custom")
2317 fromqstr(langModule->languagePackageLE->text());
2319 bp_.lang_package = fromqstr(pack);
2322 bp_.backgroundcolor = set_backgroundcolor;
2323 bp_.isbackgroundcolor = is_backgroundcolor;
2324 bp_.fontcolor = set_fontcolor;
2325 bp_.isfontcolor = is_fontcolor;
2326 bp_.notefontcolor = set_notefontcolor;
2327 bp_.boxbgcolor = set_boxbgcolor;
2330 if (bp_.documentClass().hasTocLevels()) {
2331 bp_.tocdepth = numberingModule->tocSL->value();
2332 bp_.secnumdepth = numberingModule->depthSL->value();
2336 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2337 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2338 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2339 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2342 bp_.graphics_driver =
2343 tex_graphics[latexModule->psdriverCO->currentIndex()];
2346 int idx = latexModule->classCO->currentIndex();
2348 string const classname = classes_model_.getIDString(idx);
2349 bp_.setBaseClass(classname);
2353 modulesToParams(bp_);
2356 if (mathsModule->amsautoCB->isChecked())
2357 bp_.use_amsmath = BufferParams::package_auto;
2359 if (mathsModule->amsCB->isChecked())
2360 bp_.use_amsmath = BufferParams::package_on;
2362 bp_.use_amsmath = BufferParams::package_off;
2364 if (mathsModule->esintautoCB->isChecked())
2365 bp_.use_esint = BufferParams::package_auto;
2367 if (mathsModule->esintCB->isChecked())
2368 bp_.use_esint = BufferParams::package_on;
2370 bp_.use_esint = BufferParams::package_off;
2372 if (mathsModule->mhchemautoCB->isChecked())
2373 bp_.use_mhchem = BufferParams::package_auto;
2375 if (mathsModule->mhchemCB->isChecked())
2376 bp_.use_mhchem = BufferParams::package_on;
2378 bp_.use_mhchem = BufferParams::package_off;
2380 if (mathsModule->mathdotsautoCB->isChecked())
2381 bp_.use_mathdots = BufferParams::package_auto;
2383 if (mathsModule->mathdotsCB->isChecked())
2384 bp_.use_mathdots = BufferParams::package_on;
2386 bp_.use_mathdots = BufferParams::package_off;
2388 if (mathsModule->undertildeautoCB->isChecked())
2389 bp_.use_undertilde = BufferParams::package_auto;
2391 if (mathsModule->undertildeCB->isChecked())
2392 bp_.use_undertilde = BufferParams::package_on;
2394 bp_.use_undertilde = BufferParams::package_off;
2398 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2399 bp_.pagestyle = "default";
2401 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2402 for (size_t i = 0; i != pagestyles.size(); ++i)
2403 if (pagestyles[i].second == style_gui)
2404 bp_.pagestyle = pagestyles[i].first;
2408 switch (textLayoutModule->lspacingCO->currentIndex()) {
2410 bp_.spacing().set(Spacing::Single);
2413 bp_.spacing().set(Spacing::Onehalf);
2416 bp_.spacing().set(Spacing::Double);
2419 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2421 bp_.spacing().set(Spacing::Single);
2423 bp_.spacing().set(Spacing::Other, s);
2428 if (textLayoutModule->twoColumnCB->isChecked())
2433 bp_.justification = textLayoutModule->justCB->isChecked();
2435 if (textLayoutModule->indentRB->isChecked()) {
2436 // if paragraphs are separated by an indentation
2437 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2438 switch (textLayoutModule->indentCO->currentIndex()) {
2440 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2443 HSpace indent = HSpace(
2444 widgetsToLength(textLayoutModule->indentLE,
2445 textLayoutModule->indentLengthCO)
2447 bp_.setIndentation(indent);
2451 // this should never happen
2452 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2456 // if paragraphs are separated by a skip
2457 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2458 switch (textLayoutModule->skipCO->currentIndex()) {
2460 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2463 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2466 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2471 widgetsToLength(textLayoutModule->skipLE,
2472 textLayoutModule->skipLengthCO)
2478 // this should never happen
2479 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2485 fromqstr(latexModule->optionsLE->text());
2487 bp_.use_default_options =
2488 latexModule->defaultOptionsCB->isChecked();
2490 if (latexModule->childDocGB->isChecked())
2492 fromqstr(latexModule->childDocLE->text());
2494 bp_.master = string();
2497 bp_.clearIncludedChildren();
2498 if (masterChildModule->includeonlyRB->isChecked()) {
2499 list<string>::const_iterator it = includeonlys_.begin();
2500 for (; it != includeonlys_.end() ; ++it) {
2501 bp_.addIncludedChildren(*it);
2504 bp_.maintain_unincluded_children =
2505 masterChildModule->maintainAuxCB->isChecked();
2508 bp_.float_placement = floatModule->get();
2511 // text should have passed validation
2512 bp_.listings_params =
2513 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2516 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2517 outputModule->defaultFormatCO->currentIndex()).toString());
2519 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2520 bp_.useNonTeXFonts = nontexfonts;
2522 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2524 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2526 int mathfmt = outputModule->mathoutCB->currentIndex();
2529 BufferParams::MathOutput const mo =
2530 static_cast<BufferParams::MathOutput>(mathfmt);
2531 bp_.html_math_output = mo;
2532 bp_.html_be_strict = outputModule->strictCB->isChecked();
2533 bp_.html_css_as_file = outputModule->cssCB->isChecked();
2534 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2538 fromqstr(fontModule->fontsRomanCO->
2539 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2542 fromqstr(fontModule->fontsSansCO->
2543 itemData(fontModule->fontsSansCO->currentIndex()).toString());
2545 bp_.fonts_typewriter =
2546 fromqstr(fontModule->fontsTypewriterCO->
2547 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2549 if (fontModule->fontencCO->currentIndex() == 0)
2550 bp_.fontenc = "global";
2551 else if (fontModule->fontencCO->currentIndex() == 1)
2552 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2553 else if (fontModule->fontencCO->currentIndex() == 2)
2554 bp_.fontenc = "default";
2557 fromqstr(fontModule->cjkFontLE->text());
2559 bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2561 bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2563 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2565 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2568 bp_.fonts_default_family = "default";
2570 bp_.fonts_default_family = GuiDocument::fontfamilies[
2571 fontModule->fontsDefaultCO->currentIndex()];
2573 if (fontModule->fontsizeCO->currentIndex() == 0)
2574 bp_.fontsize = "default";
2577 fromqstr(fontModule->fontsizeCO->currentText());
2580 bp_.papersize = PAPER_SIZE(
2581 pageLayoutModule->papersizeCO->currentIndex());
2583 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2584 pageLayoutModule->paperwidthUnitCO);
2586 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2587 pageLayoutModule->paperheightUnitCO);
2589 if (pageLayoutModule->facingPagesCB->isChecked())
2590 bp_.sides = TwoSides;
2592 bp_.sides = OneSide;
2594 if (pageLayoutModule->landscapeRB->isChecked())
2595 bp_.orientation = ORIENTATION_LANDSCAPE;
2597 bp_.orientation = ORIENTATION_PORTRAIT;
2600 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2602 Ui::MarginsUi const * m = marginsModule;
2604 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2605 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2606 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2607 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2608 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2609 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2610 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2611 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2614 branchesModule->apply(bp_);
2617 PDFOptions & pdf = bp_.pdfoptions();
2618 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2619 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2620 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2621 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2622 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2624 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2625 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2626 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2627 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2629 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2630 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2631 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2632 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2634 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2635 if (pdfSupportModule->fullscreenCB->isChecked())
2636 pdf.pagemode = pdf.pagemode_fullscreen;
2638 pdf.pagemode.clear();
2639 pdf.quoted_options = pdf.quoted_options_check(
2640 fromqstr(pdfSupportModule->optionsLE->text()));
2644 void GuiDocument::paramsToDialog()
2646 // set the default unit
2647 Length::UNIT const default_unit = Length::defaultUnit();
2650 preambleModule->update(bp_, id());
2651 localLayout->update(bp_, id());
2654 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2655 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2658 biblioModule->citeDefaultRB->setChecked(
2659 bp_.citeEngine() == ENGINE_BASIC);
2661 biblioModule->citeNatbibRB->setChecked(
2662 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2663 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2665 biblioModule->citeStyleCO->setCurrentIndex(
2666 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2668 biblioModule->citeJurabibRB->setChecked(
2669 bp_.citeEngine() == ENGINE_JURABIB);
2671 biblioModule->bibtopicCB->setChecked(
2676 split(bp_.bibtex_command, command, ' ');
2678 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2680 biblioModule->bibtexCO->setCurrentIndex(bpos);
2681 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
2683 // We reset to default if we do not know the specified compiler
2684 // This is for security reasons
2685 biblioModule->bibtexCO->setCurrentIndex(
2686 biblioModule->bibtexCO->findData(toqstr("default")));
2687 biblioModule->bibtexOptionsLE->clear();
2689 biblioModule->bibtexOptionsLE->setEnabled(
2690 biblioModule->bibtexCO->currentIndex() != 0);
2693 indicesModule->update(bp_);
2695 // language & quotes
2696 int const pos = langModule->languageCO->findData(toqstr(
2697 bp_.language->lang()));
2698 langModule->languageCO->setCurrentIndex(pos);
2700 langModule->quoteStyleCO->setCurrentIndex(
2701 bp_.quotes_language);
2703 bool default_enc = true;
2704 if (bp_.inputenc != "auto") {
2705 default_enc = false;
2706 if (bp_.inputenc == "default") {
2707 langModule->encodingCO->setCurrentIndex(0);
2710 Encodings::const_iterator it = encodings.begin();
2711 Encodings::const_iterator const end = encodings.end();
2712 for (; it != end; ++it) {
2713 if (it->latexName() == bp_.inputenc) {
2714 enc_gui = it->guiName();
2718 int const i = langModule->encodingCO->findText(
2721 langModule->encodingCO->setCurrentIndex(i);
2723 // unknown encoding. Set to default.
2727 langModule->defaultencodingRB->setChecked(default_enc);
2728 langModule->otherencodingRB->setChecked(!default_enc);
2730 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2732 langModule->languagePackageCO->setCurrentIndex(
2733 langModule->languagePackageCO->findData("custom"));
2734 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
2736 langModule->languagePackageCO->setCurrentIndex(p);
2737 langModule->languagePackageLE->clear();
2741 if (bp_.isfontcolor) {
2742 colorModule->fontColorPB->setStyleSheet(
2743 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2745 set_fontcolor = bp_.fontcolor;
2746 is_fontcolor = bp_.isfontcolor;
2748 colorModule->noteFontColorPB->setStyleSheet(
2749 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2750 set_notefontcolor = bp_.notefontcolor;
2752 if (bp_.isbackgroundcolor) {
2753 colorModule->backgroundPB->setStyleSheet(
2754 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2756 set_backgroundcolor = bp_.backgroundcolor;
2757 is_backgroundcolor = bp_.isbackgroundcolor;
2759 colorModule->boxBackgroundPB->setStyleSheet(
2760 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2761 set_boxbgcolor = bp_.boxbgcolor;
2764 int const min_toclevel = documentClass().min_toclevel();
2765 int const max_toclevel = documentClass().max_toclevel();
2766 if (documentClass().hasTocLevels()) {
2767 numberingModule->setEnabled(true);
2768 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2769 numberingModule->depthSL->setMaximum(max_toclevel);
2770 numberingModule->depthSL->setValue(bp_.secnumdepth);
2771 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2772 numberingModule->tocSL->setMaximum(max_toclevel);
2773 numberingModule->tocSL->setValue(bp_.tocdepth);
2776 numberingModule->setEnabled(false);
2777 numberingModule->tocTW->clear();
2781 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2782 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2783 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2784 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2785 bulletsModule->init();
2788 int nitem = findToken(tex_graphics, bp_.graphics_driver);
2790 latexModule->psdriverCO->setCurrentIndex(nitem);
2793 mathsModule->amsCB->setChecked(
2794 bp_.use_amsmath == BufferParams::package_on);
2795 mathsModule->amsautoCB->setChecked(
2796 bp_.use_amsmath == BufferParams::package_auto);
2798 mathsModule->esintCB->setChecked(
2799 bp_.use_esint == BufferParams::package_on);
2800 mathsModule->esintautoCB->setChecked(
2801 bp_.use_esint == BufferParams::package_auto);
2803 mathsModule->mhchemCB->setChecked(
2804 bp_.use_mhchem == BufferParams::package_on);
2805 mathsModule->mhchemautoCB->setChecked(
2806 bp_.use_mhchem == BufferParams::package_auto);
2808 mathsModule->mathdotsCB->setChecked(
2809 bp_.use_mathdots == BufferParams::package_on);
2810 mathsModule->mathdotsautoCB->setChecked(
2811 bp_.use_mathdots == BufferParams::package_auto);
2813 mathsModule->undertildeCB->setChecked(
2814 bp_.use_undertilde == BufferParams::package_on);
2815 mathsModule->undertildeautoCB->setChecked(
2816 bp_.use_undertilde == BufferParams::package_auto);
2818 switch (bp_.spacing().getSpace()) {
2819 case Spacing::Other: nitem = 3; break;
2820 case Spacing::Double: nitem = 2; break;
2821 case Spacing::Onehalf: nitem = 1; break;
2822 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2826 string const & layoutID = bp_.baseClassID();
2827 setLayoutComboByIDString(layoutID);
2829 updatePagestyle(documentClass().opt_pagestyle(),
2832 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2833 if (bp_.spacing().getSpace() == Spacing::Other) {
2834 doubleToWidget(textLayoutModule->lspacingLE,
2835 bp_.spacing().getValueAsString());
2839 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2840 textLayoutModule->indentRB->setChecked(true);
2841 string indentation = bp_.getIndentation().asLyXCommand();
2843 if (indentation != "default") {
2844 lengthToWidgets(textLayoutModule->indentLE,
2845 textLayoutModule->indentLengthCO,
2846 indentation, default_unit);
2849 textLayoutModule->indentCO->setCurrentIndex(indent);
2852 textLayoutModule->skipRB->setChecked(true);
2854 switch (bp_.getDefSkip().kind()) {
2855 case VSpace::SMALLSKIP:
2858 case VSpace::MEDSKIP:
2861 case VSpace::BIGSKIP:
2864 case VSpace::LENGTH:
2867 string const length = bp_.getDefSkip().asLyXCommand();
2868 lengthToWidgets(textLayoutModule->skipLE,
2869 textLayoutModule->skipLengthCO,
2870 length, default_unit);
2877 textLayoutModule->skipCO->setCurrentIndex(skip);
2881 textLayoutModule->twoColumnCB->setChecked(
2883 textLayoutModule->justCB->setChecked(bp_.justification);
2885 if (!bp_.options.empty()) {
2886 latexModule->optionsLE->setText(
2887 toqstr(bp_.options));
2889 latexModule->optionsLE->setText(QString());
2893 latexModule->defaultOptionsCB->setChecked(
2894 bp_.use_default_options);
2895 updateSelectedModules();
2896 selectionManager->updateProvidedModules(
2897 bp_.baseClass()->providedModules());
2898 selectionManager->updateExcludedModules(
2899 bp_.baseClass()->excludedModules());
2901 if (!documentClass().options().empty()) {
2902 latexModule->defaultOptionsLE->setText(
2903 toqstr(documentClass().options()));
2905 latexModule->defaultOptionsLE->setText(
2906 toqstr(_("[No options predefined]")));
2909 latexModule->defaultOptionsLE->setEnabled(
2910 bp_.use_default_options
2911 && !documentClass().options().empty());
2913 latexModule->defaultOptionsCB->setEnabled(
2914 !documentClass().options().empty());
2916 if (!bp_.master.empty()) {
2917 latexModule->childDocGB->setChecked(true);
2918 latexModule->childDocLE->setText(
2919 toqstr(bp_.master));
2921 latexModule->childDocLE->setText(QString());
2922 latexModule->childDocGB->setChecked(false);
2926 if (!bufferview() || !buffer().hasChildren()) {
2927 masterChildModule->childrenTW->clear();
2928 includeonlys_.clear();
2929 docPS->showPanel(qt_("Child Documents"), false);
2930 if (docPS->isCurrentPanel(qt_("Child Documents")))
2931 docPS->setCurrentPanel(qt_("Document Class"));
2933 docPS->showPanel(qt_("Child Documents"), true);
2934 masterChildModule->setEnabled(true);
2935 includeonlys_ = bp_.getIncludedChildren();
2936 updateIncludeonlys();
2938 masterChildModule->maintainAuxCB->setChecked(
2939 bp_.maintain_unincluded_children);
2942 floatModule->set(bp_.float_placement);
2945 // break listings_params to multiple lines
2947 InsetListingsParams(bp_.listings_params).separatedParams();
2948 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2951 // update combobox with formats
2952 updateDefaultFormat();
2953 int index = outputModule->defaultFormatCO->findData(toqstr(
2954 bp_.default_output_format));
2955 // set to default if format is not found
2958 outputModule->defaultFormatCO->setCurrentIndex(index);
2959 bool const os_fonts_available =
2960 bp_.baseClass()->outputType() == lyx::LATEX
2961 && LaTeXFeatures::isAvailable("fontspec");
2962 fontModule->osFontsCB->setEnabled(os_fonts_available);
2963 fontModule->osFontsCB->setChecked(
2964 os_fonts_available && bp_.useNonTeXFonts);
2966 outputModule->outputsyncCB->setChecked(bp_.output_sync);
2967 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2969 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2970 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2971 outputModule->strictCB->setChecked(bp_.html_be_strict);
2972 outputModule->cssCB->setChecked(bp_.html_css_as_file);
2975 updateFontsize(documentClass().opt_fontsize(),
2978 QString font = toqstr(bp_.fonts_roman);
2979 int rpos = fontModule->fontsRomanCO->findData(font);
2981 rpos = fontModule->fontsRomanCO->count();
2982 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
2984 fontModule->fontsRomanCO->setCurrentIndex(rpos);
2986 font = toqstr(bp_.fonts_sans);
2987 int spos = fontModule->fontsSansCO->findData(font);
2989 spos = fontModule->fontsSansCO->count();
2990 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
2992 fontModule->fontsSansCO->setCurrentIndex(spos);
2994 font = toqstr(bp_.fonts_typewriter);
2995 int tpos = fontModule->fontsTypewriterCO->findData(font);
2997 tpos = fontModule->fontsTypewriterCO->count();
2998 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3000 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3002 if (bp_.useNonTeXFonts && os_fonts_available) {
3003 fontModule->fontencLA->setEnabled(false);
3004 fontModule->fontencCO->setEnabled(false);
3005 fontModule->fontencLE->setEnabled(false);
3007 fontModule->fontencLA->setEnabled(true);
3008 fontModule->fontencCO->setEnabled(true);
3009 fontModule->fontencLE->setEnabled(true);
3015 if (!bp_.fonts_cjk.empty())
3016 fontModule->cjkFontLE->setText(
3017 toqstr(bp_.fonts_cjk));
3019 fontModule->cjkFontLE->setText(QString());
3021 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3022 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3023 fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
3024 fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
3026 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3028 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3030 if (bp_.fontenc == "global") {
3031 fontModule->fontencCO->setCurrentIndex(0);
3032 fontModule->fontencLE->setEnabled(false);
3033 } else if (bp_.fontenc == "default") {
3034 fontModule->fontencCO->setCurrentIndex(2);
3035 fontModule->fontencLE->setEnabled(false);
3037 fontModule->fontencCO->setCurrentIndex(1);
3038 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3042 bool const extern_geometry =
3043 documentClass().provides("geometry");
3044 int const psize = bp_.papersize;
3045 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3046 setCustomPapersize(!extern_geometry && psize == 1);
3047 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3049 bool const landscape =
3050 bp_.orientation == ORIENTATION_LANDSCAPE;
3051 pageLayoutModule->landscapeRB->setChecked(landscape);
3052 pageLayoutModule->portraitRB->setChecked(!landscape);
3053 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3054 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3056 pageLayoutModule->facingPagesCB->setChecked(
3057 bp_.sides == TwoSides);
3059 lengthToWidgets(pageLayoutModule->paperwidthLE,
3060 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3061 lengthToWidgets(pageLayoutModule->paperheightLE,
3062 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3065 Ui::MarginsUi * m = marginsModule;
3069 lengthToWidgets(m->topLE, m->topUnit,
3070 bp_.topmargin, default_unit);
3072 lengthToWidgets(m->bottomLE, m->bottomUnit,
3073 bp_.bottommargin, default_unit);
3075 lengthToWidgets(m->innerLE, m->innerUnit,
3076 bp_.leftmargin, default_unit);
3078 lengthToWidgets(m->outerLE, m->outerUnit,
3079 bp_.rightmargin, default_unit);
3081 lengthToWidgets(m->headheightLE, m->headheightUnit,
3082 bp_.headheight, default_unit);
3084 lengthToWidgets(m->headsepLE, m->headsepUnit,
3085 bp_.headsep, default_unit);
3087 lengthToWidgets(m->footskipLE, m->footskipUnit,
3088 bp_.footskip, default_unit);
3090 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3091 bp_.columnsep, default_unit);
3094 updateUnknownBranches();
3095 branchesModule->update(bp_);
3098 PDFOptions const & pdf = bp_.pdfoptions();
3099 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3100 if (bp_.documentClass().provides("hyperref"))
3101 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3103 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3104 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3105 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3106 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3107 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3109 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3110 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3111 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3113 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3115 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3116 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3117 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3118 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3120 nn = findToken(backref_opts, pdf.backref);
3122 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3124 pdfSupportModule->fullscreenCB->setChecked
3125 (pdf.pagemode == pdf.pagemode_fullscreen);
3127 pdfSupportModule->optionsLE->setText(
3128 toqstr(pdf.quoted_options));
3130 // Make sure that the bc is in the INITIAL state
3131 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3134 // clear changed branches cache
3135 changedBranches_.clear();
3139 void GuiDocument::saveDocDefault()
3141 // we have to apply the params first
3147 void GuiDocument::updateAvailableModules()
3149 modules_av_model_.clear();
3150 list<modInfoStruct> const & modInfoList = getModuleInfo();
3151 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3152 list<modInfoStruct>::const_iterator men = modInfoList.end();
3153 for (int i = 0; mit != men; ++mit, ++i)
3154 modules_av_model_.insertRow(i, mit->name, mit->id,
3159 void GuiDocument::updateSelectedModules()
3161 modules_sel_model_.clear();
3162 list<modInfoStruct> const selModList = getSelectedModules();
3163 list<modInfoStruct>::const_iterator mit = selModList.begin();
3164 list<modInfoStruct>::const_iterator men = selModList.end();
3165 for (int i = 0; mit != men; ++mit, ++i)
3166 modules_sel_model_.insertRow(i, mit->name, mit->id,
3171 void GuiDocument::updateIncludeonlys()
3173 masterChildModule->childrenTW->clear();
3174 QString const no = qt_("No");
3175 QString const yes = qt_("Yes");
3177 if (includeonlys_.empty()) {
3178 masterChildModule->includeallRB->setChecked(true);
3179 masterChildModule->childrenTW->setEnabled(false);
3180 masterChildModule->maintainAuxCB->setEnabled(false);
3182 masterChildModule->includeonlyRB->setChecked(true);
3183 masterChildModule->childrenTW->setEnabled(true);
3184 masterChildModule->maintainAuxCB->setEnabled(true);
3186 QTreeWidgetItem * item = 0;
3187 ListOfBuffers children = buffer().getChildren();
3188 ListOfBuffers::const_iterator it = children.begin();
3189 ListOfBuffers::const_iterator end = children.end();
3190 bool has_unincluded = false;
3191 bool all_unincluded = true;
3192 for (; it != end; ++it) {
3193 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3196 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3197 from_utf8(buffer().filePath())));
3198 item->setText(0, toqstr(name));
3199 item->setText(1, isChildIncluded(name) ? yes : no);
3200 if (!isChildIncluded(name))
3201 has_unincluded = true;
3203 all_unincluded = false;
3205 // Both if all childs are included and if none is included
3206 // is equal to "include all" (i.e., ommit \includeonly).
3207 // Thus, reset the GUI.
3208 if (!has_unincluded || all_unincluded) {
3209 masterChildModule->includeallRB->setChecked(true);
3210 masterChildModule->childrenTW->setEnabled(false);
3211 includeonlys_.clear();
3213 // If all are included, we need to update again.
3214 if (!has_unincluded)
3215 updateIncludeonlys();
3219 void GuiDocument::updateContents()
3221 // Nothing to do here as the document settings is not cursor dependant.
3226 void GuiDocument::useClassDefaults()
3228 if (applyPB->isEnabled()) {
3229 int const ret = Alert::prompt(_("Unapplied changes"),
3230 _("Some changes in the dialog were not yet applied.\n"
3231 "If you do not apply now, they will be lost after this action."),
3232 1, 1, _("&Apply"), _("&Dismiss"));
3237 int idx = latexModule->classCO->currentIndex();
3238 string const classname = classes_model_.getIDString(idx);
3239 if (!bp_.setBaseClass(classname)) {
3240 Alert::error(_("Error"), _("Unable to set document class."));
3243 bp_.useClassDefaults();
3248 void GuiDocument::setLayoutComboByIDString(string const & idString)
3250 int idx = classes_model_.findIDString(idString);
3252 Alert::warning(_("Can't set layout!"),
3253 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3255 latexModule->classCO->setCurrentIndex(idx);
3259 bool GuiDocument::isValid()
3262 validateListingsParameters().isEmpty() &&
3263 localLayout->isValid() &&
3265 // if we're asking for skips between paragraphs
3266 !textLayoutModule->skipRB->isChecked() ||
3267 // then either we haven't chosen custom
3268 textLayoutModule->skipCO->currentIndex() != 3 ||
3269 // or else a length has been given
3270 !textLayoutModule->skipLE->text().isEmpty()
3273 // if we're asking for indentation
3274 !textLayoutModule->indentRB->isChecked() ||
3275 // then either we haven't chosen custom
3276 textLayoutModule->indentCO->currentIndex() != 1 ||
3277 // or else a length has been given
3278 !textLayoutModule->indentLE->text().isEmpty()
3283 char const * const GuiDocument::fontfamilies[5] = {
3284 "default", "rmdefault", "sfdefault", "ttdefault", ""
3288 char const * GuiDocument::fontfamilies_gui[5] = {
3289 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3293 bool GuiDocument::initialiseParams(string const &)
3295 BufferView const * view = bufferview();
3297 bp_ = BufferParams();
3301 bp_ = view->buffer().params();
3303 updateAvailableModules();
3304 //FIXME It'd be nice to make sure here that the selected
3305 //modules are consistent: That required modules are actually
3306 //selected, and that we don't have conflicts. If so, we could
3307 //at least pop up a warning.
3313 void GuiDocument::clearParams()
3315 bp_ = BufferParams();
3319 BufferId GuiDocument::id() const
3321 BufferView const * const view = bufferview();
3322 return view? &view->buffer() : 0;
3326 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3328 return moduleNames_;
3332 list<GuiDocument::modInfoStruct> const
3333 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3335 LayoutModuleList::const_iterator it = mods.begin();
3336 LayoutModuleList::const_iterator end = mods.end();
3337 list<modInfoStruct> mInfo;
3338 for (; it != end; ++it) {
3341 LyXModule const * const mod = theModuleList[*it];
3344 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3346 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3353 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3355 return makeModuleInfo(params().getModules());
3359 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3361 return makeModuleInfo(params().baseClass()->providedModules());
3365 DocumentClass const & GuiDocument::documentClass() const
3367 return bp_.documentClass();
3371 static void dispatch_bufferparams(Dialog const & dialog,
3372 BufferParams const & bp, FuncCode lfun)
3375 ss << "\\begin_header\n";
3377 ss << "\\end_header\n";
3378 dialog.dispatch(FuncRequest(lfun, ss.str()));
3382 void GuiDocument::dispatchParams()
3384 // This must come first so that a language change is correctly noticed
3387 // Apply the BufferParams. Note that this will set the base class
3388 // and then update the buffer's layout.
3389 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3391 if (!params().master.empty()) {
3392 FileName const master_file = support::makeAbsPath(params().master,
3393 support::onlyPath(buffer().absFileName()));
3394 if (isLyXFileName(master_file.absFileName())) {
3395 Buffer * master = checkAndLoadLyXFile(master_file);
3397 if (master->isChild(const_cast<Buffer *>(&buffer())))
3398 const_cast<Buffer &>(buffer()).setParent(master);
3400 Alert::warning(_("Assigned master does not include this file"),
3401 bformat(_("You must include this file in the document\n"
3402 "'%1$s' in order to use the master document\n"
3403 "feature."), from_utf8(params().master)));
3405 Alert::warning(_("Could not load master"),
3406 bformat(_("The master document '%1$s'\n"
3407 "could not be loaded."),
3408 from_utf8(params().master)));
3412 // Generate the colours requested by each new branch.
3413 BranchList & branchlist = params().branchlist();
3414 if (!branchlist.empty()) {
3415 BranchList::const_iterator it = branchlist.begin();
3416 BranchList::const_iterator const end = branchlist.end();
3417 for (; it != end; ++it) {
3418 docstring const & current_branch = it->branch();
3419 Branch const * branch = branchlist.find(current_branch);
3420 string const x11hexname = X11hexname(branch->color());
3421 // display the new color
3422 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3423 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3426 // Open insets of selected branches, close deselected ones
3427 dispatch(FuncRequest(LFUN_INSET_FORALL,
3428 "Branch inset-toggle assign"));
3430 // rename branches in the document
3431 executeBranchRenaming();
3432 // and clear changed branches cache
3433 changedBranches_.clear();
3435 // Generate the colours requested by indices.
3436 IndicesList & indiceslist = params().indiceslist();
3437 if (!indiceslist.empty()) {
3438 IndicesList::const_iterator it = indiceslist.begin();
3439 IndicesList::const_iterator const end = indiceslist.end();
3440 for (; it != end; ++it) {
3441 docstring const & current_index = it->shortcut();
3442 Index const * index = indiceslist.findShortcut(current_index);
3443 string const x11hexname = X11hexname(index->color());
3444 // display the new color
3445 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3446 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3450 // If we used an LFUN, we would not need these two lines:
3451 BufferView * bv = const_cast<BufferView *>(bufferview());
3452 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3456 void GuiDocument::setLanguage() const
3458 Language const * const newL = bp_.language;
3459 if (buffer().params().language == newL)
3462 string const & lang_name = newL->lang();
3463 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3467 void GuiDocument::saveAsDefault() const
3469 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3473 bool GuiDocument::isFontAvailable(string const & font) const
3475 if (font == "default" || font == "cmr"
3476 || font == "cmss" || font == "cmtt")
3477 // these are standard
3479 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3480 return LaTeXFeatures::isAvailable("lmodern");
3481 if (font == "times" || font == "palatino"
3482 || font == "helvet" || font == "courier")
3483 return LaTeXFeatures::isAvailable("psnfss");
3484 if (font == "cmbr" || font == "cmtl")
3485 return LaTeXFeatures::isAvailable("cmbright");
3486 if (font == "utopia")
3487 return LaTeXFeatures::isAvailable("utopia")
3488 || LaTeXFeatures::isAvailable("fourier");
3489 if (font == "beraserif" || font == "berasans"
3490 || font == "beramono")
3491 return LaTeXFeatures::isAvailable("bera");
3492 return LaTeXFeatures::isAvailable(font);
3496 bool GuiDocument::providesOSF(string const & font) const
3498 if (fontModule->osFontsCB->isChecked())
3499 // FIXME: we should check if the fonts really
3500 // have OSF support. But how?
3503 return isFontAvailable("eco");
3504 if (font == "palatino")
3505 return isFontAvailable("mathpazo");
3510 bool GuiDocument::providesSC(string const & font) const
3512 if (fontModule->osFontsCB->isChecked())
3514 if (font == "palatino")
3515 return isFontAvailable("mathpazo");
3516 if (font == "utopia")
3517 return isFontAvailable("fourier");
3522 bool GuiDocument::providesScale(string const & font) const
3524 if (fontModule->osFontsCB->isChecked())
3526 return font == "helvet" || font == "luximono"
3527 || font == "berasans" || font == "beramono";
3531 void GuiDocument::loadModuleInfo()
3533 moduleNames_.clear();
3534 LyXModuleList::const_iterator it = theModuleList.begin();
3535 LyXModuleList::const_iterator end = theModuleList.end();
3536 for (; it != end; ++it) {
3540 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3541 // this is supposed to give us the first sentence of the description
3544 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3545 int const pos = desc.indexOf(".");
3547 desc.truncate(pos + 1);
3548 m.description = desc;
3549 moduleNames_.push_back(m);
3554 void GuiDocument::updateUnknownBranches()
3558 list<docstring> used_branches;
3559 buffer().getUsedBranches(used_branches);
3560 list<docstring>::const_iterator it = used_branches.begin();
3561 QStringList unknown_branches;
3562 for (; it != used_branches.end() ; ++it) {
3563 if (!buffer().params().branchlist().find(*it))
3564 unknown_branches.append(toqstr(*it));
3566 branchesModule->setUnknownBranches(unknown_branches);
3570 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3572 map<docstring, docstring>::iterator it = changedBranches_.begin();
3573 for (; it != changedBranches_.end() ; ++it) {
3574 if (it->second == oldname) {
3575 // branch has already been renamed
3576 it->second = newname;
3581 changedBranches_[oldname] = newname;
3585 void GuiDocument::executeBranchRenaming() const
3587 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3588 for (; it != changedBranches_.end() ; ++it) {
3589 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3590 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3595 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3598 } // namespace frontend
3601 #include "moc_GuiDocument.cpp"