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"
50 #include "insets/InsetListingsParams.h"
52 #include "support/debug.h"
53 #include "support/FileName.h"
54 #include "support/filetools.h"
55 #include "support/gettext.h"
56 #include "support/lstrings.h"
58 #include "frontends/alert.h"
60 #include <QAbstractItemModel>
61 #include <QHeaderView>
63 #include <QColorDialog>
64 #include <QCloseEvent>
65 #include <QFontDatabase>
67 #include <QTextCursor>
77 // a style sheet for buttons
78 // this is for example used for the background color setting button
79 static inline QString colorButtonStyleSheet(QColor const & bgColor)
81 if (bgColor.isValid()) {
82 QString rc = QLatin1String("background:");
91 using namespace lyx::support;
96 char const * const tex_graphics[] =
98 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
99 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
100 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
101 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
106 char const * const tex_graphics_gui[] =
108 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
109 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
110 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
111 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
112 "XeTeX", N_("None"), ""
116 char const * const tex_fonts_roman[] =
118 "default", "cmr", "lmodern", "ae", "times", "palatino",
119 "charter", "newcent", "bookman", "utopia", "beraserif",
120 "ccfonts", "chancery", ""
124 char const * tex_fonts_roman_gui[] =
126 N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
127 N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
128 N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
129 N_("Utopia"), N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
134 char const * const tex_fonts_sans[] =
136 "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
140 char const * tex_fonts_sans_gui[] =
142 N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
143 N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
147 char const * const tex_fonts_monospaced[] =
149 "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
153 char const * tex_fonts_monospaced_gui[] =
155 N_("Default"), N_("Computer Modern Typewriter"),
156 N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
157 N_("LuxiMono"), N_("CM Typewriter Light"), ""
161 char const * backref_opts[] =
163 "false", "section", "slide", "page", ""
167 char const * backref_opts_gui[] =
169 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
173 vector<pair<string, QString> > pagestyles;
176 } // anonymous namespace
180 RGBColor set_backgroundcolor;
183 // used when sorting the textclass list.
184 class less_textclass_avail_desc
185 : public binary_function<string, string, int>
188 bool operator()(string const & lhs, string const & rhs) const
190 // Ordering criteria:
191 // 1. Availability of text class
192 // 2. Description (lexicographic)
193 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
194 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
195 int const order = compare_no_case(
196 translateIfPossible(from_utf8(tc1.description())),
197 translateIfPossible(from_utf8(tc2.description())));
198 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
199 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
208 vector<string> getRequiredList(string const & modName)
210 LyXModule const * const mod = theModuleList[modName];
212 return vector<string>(); //empty such thing
213 return mod->getRequiredModules();
217 vector<string> getExcludedList(string const & modName)
219 LyXModule const * const mod = theModuleList[modName];
221 return vector<string>(); //empty such thing
222 return mod->getExcludedModules();
226 docstring getModuleDescription(string const & modName)
228 LyXModule const * const mod = theModuleList[modName];
230 return _("Module not found!");
232 return translateIfPossible(from_utf8(mod->getDescription()));
236 vector<string> getPackageList(string const & modName)
238 LyXModule const * const mod = theModuleList[modName];
240 return vector<string>(); //empty such thing
241 return mod->getPackageList();
245 bool isModuleAvailable(string const & modName)
247 LyXModule const * const mod = theModuleList[modName];
250 return mod->isAvailable();
253 } // anonymous namespace
256 /////////////////////////////////////////////////////////////////////
258 // ModuleSelectionManager
260 /////////////////////////////////////////////////////////////////////
262 /// SelectionManager for use with modules
263 class ModuleSelectionManager : public GuiSelectionManager
267 ModuleSelectionManager(
268 QTreeView * availableLV,
269 QListView * selectedLV,
273 QPushButton * downPB,
274 GuiIdListModel * availableModel,
275 GuiIdListModel * selectedModel,
276 GuiDocument const * container)
277 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
278 upPB, downPB, availableModel, selectedModel), container_(container)
281 void updateProvidedModules(LayoutModuleList const & pm)
282 { provided_modules_ = pm.list(); }
284 void updateExcludedModules(LayoutModuleList const & em)
285 { excluded_modules_ = em.list(); }
288 virtual void updateAddPB();
290 virtual void updateUpPB();
292 virtual void updateDownPB();
294 virtual void updateDelPB();
295 /// returns availableModel as a GuiIdListModel
296 GuiIdListModel * getAvailableModel()
298 return dynamic_cast<GuiIdListModel *>(availableModel);
300 /// returns selectedModel as a GuiIdListModel
301 GuiIdListModel * getSelectedModel()
303 return dynamic_cast<GuiIdListModel *>(selectedModel);
305 /// keeps a list of the modules the text class provides
306 list<string> provided_modules_;
308 list<string> excluded_modules_;
310 GuiDocument const * container_;
313 void ModuleSelectionManager::updateAddPB()
315 int const arows = availableModel->rowCount();
316 QModelIndexList const avail_sels =
317 availableLV->selectionModel()->selectedIndexes();
319 // disable if there aren't any modules (?), if none of them is chosen
320 // in the dialog, or if the chosen one is already selected for use.
321 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
322 addPB->setEnabled(false);
326 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
327 string const modname = getAvailableModel()->getIDString(idx.row());
330 container_->params().moduleCanBeAdded(modname);
331 addPB->setEnabled(enable);
335 void ModuleSelectionManager::updateDownPB()
337 int const srows = selectedModel->rowCount();
339 downPB->setEnabled(false);
342 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
343 int const curRow = curidx.row();
344 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
345 downPB->setEnabled(false);
349 // determine whether immediately succeding element requires this one
350 string const curmodname = getSelectedModel()->getIDString(curRow);
351 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
353 vector<string> reqs = getRequiredList(nextmodname);
355 // if it doesn't require anything....
357 downPB->setEnabled(true);
361 // Enable it if this module isn't required.
362 // FIXME This should perhaps be more flexible and check whether, even
363 // if the next one is required, there is also an earlier one that will do.
365 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
368 void ModuleSelectionManager::updateUpPB()
370 int const srows = selectedModel->rowCount();
372 upPB->setEnabled(false);
376 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
377 int curRow = curIdx.row();
378 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
379 upPB->setEnabled(false);
382 string const curmodname = getSelectedModel()->getIDString(curRow);
384 // determine whether immediately preceding element is required by this one
385 vector<string> reqs = getRequiredList(curmodname);
387 // if this one doesn't require anything....
389 upPB->setEnabled(true);
394 // Enable it if the preceding module isn't required.
395 // NOTE This is less flexible than it might be. We could check whether, even
396 // if the previous one is required, there is an earlier one that would do.
397 string const premod = getSelectedModel()->getIDString(curRow - 1);
398 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
401 void ModuleSelectionManager::updateDelPB()
403 int const srows = selectedModel->rowCount();
405 deletePB->setEnabled(false);
409 QModelIndex const & curidx =
410 selectedLV->selectionModel()->currentIndex();
411 int const curRow = curidx.row();
412 if (curRow < 0 || curRow >= srows) { // invalid index?
413 deletePB->setEnabled(false);
417 string const curmodname = getSelectedModel()->getIDString(curRow);
419 // We're looking here for a reason NOT to enable the button. If we
420 // find one, we disable it and return. If we don't, we'll end up at
421 // the end of the function, and then we enable it.
422 for (int i = curRow + 1; i < srows; ++i) {
423 string const thisMod = getSelectedModel()->getIDString(i);
424 vector<string> reqs = getRequiredList(thisMod);
425 //does this one require us?
426 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
430 // OK, so this module requires us
431 // is there an EARLIER module that also satisfies the require?
432 // NOTE We demand that it be earlier to keep the list of modules
433 // consistent with the rule that a module must be proceeded by a
434 // required module. There would be more flexible ways to proceed,
435 // but that would be a lot more complicated, and the logic here is
436 // already complicated. (That's why I've left the debugging code.)
437 // lyxerr << "Testing " << thisMod << endl;
438 bool foundone = false;
439 for (int j = 0; j < curRow; ++j) {
440 string const mod = getSelectedModel()->getIDString(j);
441 // lyxerr << "In loop: Testing " << mod << endl;
442 // do we satisfy the require?
443 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
444 // lyxerr << mod << " does the trick." << endl;
449 // did we find a module to satisfy the require?
451 // lyxerr << "No matching module found." << endl;
452 deletePB->setEnabled(false);
456 // lyxerr << "All's well that ends well." << endl;
457 deletePB->setEnabled(true);
461 /////////////////////////////////////////////////////////////////////
465 /////////////////////////////////////////////////////////////////////
467 PreambleModule::PreambleModule() : current_id_(0)
469 // This is not a memory leak. The object will be destroyed
471 (void) new LaTeXHighlighter(preambleTE->document());
472 setFocusProxy(preambleTE);
473 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
477 void PreambleModule::update(BufferParams const & params, BufferId id)
479 QString preamble = toqstr(params.preamble);
480 // Nothing to do if the params and preamble are unchanged.
481 if (id == current_id_
482 && preamble == preambleTE->document()->toPlainText())
485 QTextCursor cur = preambleTE->textCursor();
486 // Save the coords before switching to the new one.
487 preamble_coords_[current_id_] =
488 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
490 // Save the params address for further use.
492 preambleTE->document()->setPlainText(preamble);
493 Coords::const_iterator it = preamble_coords_.find(current_id_);
494 if (it == preamble_coords_.end())
495 // First time we open this one.
496 preamble_coords_[current_id_] = make_pair(0, 0);
498 // Restore saved coords.
499 QTextCursor cur = preambleTE->textCursor();
500 cur.setPosition(it->second.first);
501 preambleTE->setTextCursor(cur);
502 preambleTE->verticalScrollBar()->setValue(it->second.second);
507 void PreambleModule::apply(BufferParams & params)
509 params.preamble = fromqstr(preambleTE->document()->toPlainText());
513 void PreambleModule::closeEvent(QCloseEvent * e)
515 // Save the coords before closing.
516 QTextCursor cur = preambleTE->textCursor();
517 preamble_coords_[current_id_] =
518 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
523 /////////////////////////////////////////////////////////////////////
527 /////////////////////////////////////////////////////////////////////
530 GuiDocument::GuiDocument(GuiView & lv)
531 : GuiDialog(lv, "document", qt_("Document Settings"))
535 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
536 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
537 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
538 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
540 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
541 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
543 // Manage the restore, ok, apply, restore and cancel/close buttons
544 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
546 bc().setApply(applyPB);
547 bc().setCancel(closePB);
548 bc().setRestore(restorePB);
550 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
552 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
553 this, SLOT(change_adaptor()));
554 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
555 this, SLOT(setLSpacing(int)));
556 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
557 this, SLOT(change_adaptor()));
559 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
560 this, SLOT(change_adaptor()));
561 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
562 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
563 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
564 this, SLOT(change_adaptor()));
565 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
566 this, SLOT(setIndent(int)));
567 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
568 this, SLOT(change_adaptor()));
569 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
570 this, SLOT(change_adaptor()));
572 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
573 this, SLOT(change_adaptor()));
574 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
575 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
576 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
577 this, SLOT(change_adaptor()));
578 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
579 this, SLOT(setSkip(int)));
580 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
581 this, SLOT(change_adaptor()));
582 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
583 this, SLOT(change_adaptor()));
585 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
586 this, SLOT(enableIndent(bool)));
587 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
588 this, SLOT(enableSkip(bool)));
590 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
591 this, SLOT(change_adaptor()));
592 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
593 this, SLOT(setColSep()));
595 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
596 textLayoutModule->lspacingLE));
597 textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
598 textLayoutModule->indentLE));
599 textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
600 textLayoutModule->skipLE));
602 textLayoutModule->indentCO->addItem(qt_("Default"));
603 textLayoutModule->indentCO->addItem(qt_("Custom"));
604 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
605 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
606 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
607 textLayoutModule->skipCO->addItem(qt_("Custom"));
608 textLayoutModule->lspacingCO->insertItem(
609 Spacing::Single, qt_("Single"));
610 textLayoutModule->lspacingCO->insertItem(
611 Spacing::Onehalf, qt_("OneHalf"));
612 textLayoutModule->lspacingCO->insertItem(
613 Spacing::Double, qt_("Double"));
614 textLayoutModule->lspacingCO->insertItem(
615 Spacing::Other, qt_("Custom"));
616 // initialize the length validator
617 bc().addCheckedLineEdit(textLayoutModule->indentLE);
618 bc().addCheckedLineEdit(textLayoutModule->skipLE);
620 // master/child handling
621 masterChildModule = new UiWidget<Ui::MasterChildUi>;
623 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
624 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
625 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
626 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
627 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
628 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
629 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
630 this, SLOT(change_adaptor()));
631 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
632 this, SLOT(change_adaptor()));
633 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
634 this, SLOT(change_adaptor()));
635 masterChildModule->childrenTW->setColumnCount(2);
636 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
637 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
638 masterChildModule->childrenTW->resizeColumnToContents(1);
639 masterChildModule->childrenTW->resizeColumnToContents(2);
642 outputModule = new UiWidget<Ui::OutputUi>;
644 connect(outputModule->xetexCB, SIGNAL(clicked()),
645 this, SLOT(change_adaptor()));
646 connect(outputModule->xetexCB, SIGNAL(toggled(bool)),
647 this, SLOT(xetexChanged(bool)));
648 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
649 this, SLOT(change_adaptor()));
652 fontModule = new UiWidget<Ui::FontUi>;
653 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
654 this, SLOT(change_adaptor()));
655 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
656 this, SLOT(romanChanged(int)));
657 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
658 this, SLOT(change_adaptor()));
659 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
660 this, SLOT(sansChanged(int)));
661 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
662 this, SLOT(change_adaptor()));
663 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
664 this, SLOT(ttChanged(int)));
665 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
666 this, SLOT(change_adaptor()));
667 connect(fontModule->fontencCO, SIGNAL(activated(int)),
668 this, SLOT(change_adaptor()));
669 connect(fontModule->fontencCO, SIGNAL(activated(int)),
670 this, SLOT(fontencChanged(int)));
671 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
672 this, SLOT(change_adaptor()));
673 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
674 this, SLOT(change_adaptor()));
675 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
676 this, SLOT(change_adaptor()));
677 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
678 this, SLOT(change_adaptor()));
679 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
680 this, SLOT(change_adaptor()));
681 connect(fontModule->fontScCB, SIGNAL(clicked()),
682 this, SLOT(change_adaptor()));
683 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
684 this, SLOT(change_adaptor()));
688 fontModule->fontsizeCO->addItem(qt_("Default"));
689 fontModule->fontsizeCO->addItem(qt_("10"));
690 fontModule->fontsizeCO->addItem(qt_("11"));
691 fontModule->fontsizeCO->addItem(qt_("12"));
693 fontModule->fontencCO->addItem(qt_("Default"));
694 fontModule->fontencCO->addItem(qt_("Custom"));
695 fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
697 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
698 fontModule->fontsDefaultCO->addItem(
699 qt_(GuiDocument::fontfamilies_gui[n]));
702 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
704 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
705 this, SLOT(papersizeChanged(int)));
706 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
707 this, SLOT(papersizeChanged(int)));
708 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
709 this, SLOT(portraitChanged()));
710 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
711 this, SLOT(change_adaptor()));
712 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
713 this, SLOT(change_adaptor()));
714 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
715 this, SLOT(change_adaptor()));
716 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
717 this, SLOT(change_adaptor()));
718 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
719 this, SLOT(change_adaptor()));
720 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
721 this, SLOT(change_adaptor()));
722 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
723 this, SLOT(change_adaptor()));
724 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
725 this, SLOT(change_adaptor()));
726 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
727 this, SLOT(change_adaptor()));
728 connect(pageLayoutModule->backgroundPB, SIGNAL(clicked()),
729 this, SLOT(changeBackgroundColor()));
730 connect(pageLayoutModule->delbackgroundTB, SIGNAL(clicked()),
731 this, SLOT(deleteBackgroundColor()));
733 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
734 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
735 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
736 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
737 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
738 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
739 pageLayoutModule->paperheightL);
740 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
741 pageLayoutModule->paperwidthL);
744 QComboBox * cb = pageLayoutModule->papersizeCO;
745 cb->addItem(qt_("Default"));
746 cb->addItem(qt_("Custom"));
747 cb->addItem(qt_("US letter"));
748 cb->addItem(qt_("US legal"));
749 cb->addItem(qt_("US executive"));
750 cb->addItem(qt_("A3"));
751 cb->addItem(qt_("A4"));
752 cb->addItem(qt_("A5"));
753 cb->addItem(qt_("B3"));
754 cb->addItem(qt_("B4"));
755 cb->addItem(qt_("B5"));
756 // remove the %-items from the unit choice
757 pageLayoutModule->paperwidthUnitCO->noPercents();
758 pageLayoutModule->paperheightUnitCO->noPercents();
759 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
760 pageLayoutModule->paperheightLE));
761 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
762 pageLayoutModule->paperwidthLE));
765 marginsModule = new UiWidget<Ui::MarginsUi>;
767 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
768 this, SLOT(setCustomMargins(bool)));
769 connect(marginsModule->marginCB, SIGNAL(clicked()),
770 this, SLOT(change_adaptor()));
771 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
772 this, SLOT(change_adaptor()));
773 connect(marginsModule->topUnit, SIGNAL(activated(int)),
774 this, SLOT(change_adaptor()));
775 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
776 this, SLOT(change_adaptor()));
777 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
778 this, SLOT(change_adaptor()));
779 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
780 this, SLOT(change_adaptor()));
781 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
782 this, SLOT(change_adaptor()));
783 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
784 this, SLOT(change_adaptor()));
785 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
786 this, SLOT(change_adaptor()));
787 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
788 this, SLOT(change_adaptor()));
789 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
790 this, SLOT(change_adaptor()));
791 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
792 this, SLOT(change_adaptor()));
793 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
794 this, SLOT(change_adaptor()));
795 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
796 this, SLOT(change_adaptor()));
797 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
798 this, SLOT(change_adaptor()));
799 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
800 this, SLOT(change_adaptor()));
801 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
802 this, SLOT(change_adaptor()));
803 marginsModule->topLE->setValidator(unsignedLengthValidator(
804 marginsModule->topLE));
805 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
806 marginsModule->bottomLE));
807 marginsModule->innerLE->setValidator(unsignedLengthValidator(
808 marginsModule->innerLE));
809 marginsModule->outerLE->setValidator(unsignedLengthValidator(
810 marginsModule->outerLE));
811 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
812 marginsModule->headsepLE));
813 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
814 marginsModule->headheightLE));
815 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
816 marginsModule->footskipLE));
817 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
818 marginsModule->columnsepLE));
820 bc().addCheckedLineEdit(marginsModule->topLE,
821 marginsModule->topL);
822 bc().addCheckedLineEdit(marginsModule->bottomLE,
823 marginsModule->bottomL);
824 bc().addCheckedLineEdit(marginsModule->innerLE,
825 marginsModule->innerL);
826 bc().addCheckedLineEdit(marginsModule->outerLE,
827 marginsModule->outerL);
828 bc().addCheckedLineEdit(marginsModule->headsepLE,
829 marginsModule->headsepL);
830 bc().addCheckedLineEdit(marginsModule->headheightLE,
831 marginsModule->headheightL);
832 bc().addCheckedLineEdit(marginsModule->footskipLE,
833 marginsModule->footskipL);
834 bc().addCheckedLineEdit(marginsModule->columnsepLE,
835 marginsModule->columnsepL);
838 langModule = new UiWidget<Ui::LanguageUi>;
840 connect(langModule->languageCO, SIGNAL(activated(int)),
841 this, SLOT(change_adaptor()));
842 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
843 this, SLOT(change_adaptor()));
844 connect(langModule->otherencodingRB, SIGNAL(clicked()),
845 this, SLOT(change_adaptor()));
846 connect(langModule->encodingCO, SIGNAL(activated(int)),
847 this, SLOT(change_adaptor()));
848 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
849 this, SLOT(change_adaptor()));
851 QAbstractItemModel * language_model = guiApp->languageModel();
852 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
853 language_model->sort(0);
854 langModule->languageCO->setModel(language_model);
856 // Always put the default encoding in the first position.
857 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
858 QStringList encodinglist;
859 Encodings::const_iterator it = encodings.begin();
860 Encodings::const_iterator const end = encodings.end();
861 for (; it != end; ++it)
862 encodinglist.append(qt_(it->guiName()));
864 langModule->encodingCO->addItems(encodinglist);
866 langModule->quoteStyleCO->addItem(qt_("``text''"));
867 langModule->quoteStyleCO->addItem(qt_("''text''"));
868 langModule->quoteStyleCO->addItem(qt_(",,text``"));
869 langModule->quoteStyleCO->addItem(qt_(",,text''"));
870 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
871 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
874 numberingModule = new UiWidget<Ui::NumberingUi>;
876 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
877 this, SLOT(change_adaptor()));
878 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
879 this, SLOT(change_adaptor()));
880 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
881 this, SLOT(updateNumbering()));
882 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
883 this, SLOT(updateNumbering()));
884 numberingModule->tocTW->setColumnCount(3);
885 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
886 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
887 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
890 biblioModule = new UiWidget<Ui::BiblioUi>;
891 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
892 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
893 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
894 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
896 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
897 this, SLOT(change_adaptor()));
898 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
899 this, SLOT(change_adaptor()));
900 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
901 this, SLOT(change_adaptor()));
902 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
903 this, SLOT(change_adaptor()));
904 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
905 this, SLOT(change_adaptor()));
906 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
907 this, SLOT(bibtexChanged(int)));
908 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
909 this, SLOT(change_adaptor()));
911 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
912 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
913 biblioModule->citeStyleCO->setCurrentIndex(0);
915 biblioModule->bibtexCO->clear();
917 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
918 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
919 it != lyxrc.bibtex_alternatives.end(); ++it) {
920 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
921 biblioModule->bibtexCO->addItem(command, command);
925 indicesModule = new GuiIndices;
926 connect(indicesModule, SIGNAL(changed()),
927 this, SLOT(change_adaptor()));
930 mathsModule = new UiWidget<Ui::MathsUi>;
931 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
932 mathsModule->amsCB, SLOT(setDisabled(bool)));
933 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
934 mathsModule->esintCB, SLOT(setDisabled(bool)));
935 connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
936 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
938 connect(mathsModule->amsCB, SIGNAL(clicked()),
939 this, SLOT(change_adaptor()));
940 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
941 this, SLOT(change_adaptor()));
942 connect(mathsModule->esintCB, SIGNAL(clicked()),
943 this, SLOT(change_adaptor()));
944 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
945 this, SLOT(change_adaptor()));
946 connect(mathsModule->mhchemCB, SIGNAL(clicked()),
947 this, SLOT(change_adaptor()));
948 connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
949 this, SLOT(change_adaptor()));
951 latexModule = new UiWidget<Ui::LaTeXUi>;
953 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
954 this, SLOT(change_adaptor()));
955 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
956 this, SLOT(change_adaptor()));
957 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
958 this, SLOT(change_adaptor()));
959 connect(latexModule->classCO, SIGNAL(activated(int)),
960 this, SLOT(classChanged()));
961 connect(latexModule->classCO, SIGNAL(activated(int)),
962 this, SLOT(change_adaptor()));
963 connect(latexModule->layoutPB, SIGNAL(clicked()),
964 this, SLOT(browseLayout()));
965 connect(latexModule->layoutPB, SIGNAL(clicked()),
966 this, SLOT(change_adaptor()));
967 connect(latexModule->childDocGB, SIGNAL(clicked()),
968 this, SLOT(change_adaptor()));
969 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
970 this, SLOT(change_adaptor()));
971 connect(latexModule->childDocPB, SIGNAL(clicked()),
972 this, SLOT(browseMaster()));
973 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
974 this, SLOT(change_adaptor()));
976 // postscript drivers
977 for (int n = 0; tex_graphics[n][0]; ++n) {
978 QString enc = qt_(tex_graphics_gui[n]);
979 latexModule->psdriverCO->addItem(enc);
982 latexModule->classCO->setModel(&classes_model_);
983 LayoutFileList const & bcl = LayoutFileList::get();
984 vector<LayoutFileIndex> classList = bcl.classList();
985 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
987 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
988 vector<LayoutFileIndex>::const_iterator cen = classList.end();
989 for (int i = 0; cit != cen; ++cit, ++i) {
990 LayoutFile const & tc = bcl[*cit];
991 docstring item = (tc.isTeXClassAvailable()) ?
992 from_utf8(tc.description()) :
993 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
994 classes_model_.insertRow(i, toqstr(item), *cit);
998 branchesModule = new GuiBranches;
999 connect(branchesModule, SIGNAL(changed()),
1000 this, SLOT(change_adaptor()));
1001 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1002 this, SLOT(branchesRename(docstring const &, docstring const &)));
1003 updateUnknownBranches();
1006 preambleModule = new PreambleModule;
1007 connect(preambleModule, SIGNAL(changed()),
1008 this, SLOT(change_adaptor()));
1011 bulletsModule = new BulletsModule;
1012 connect(bulletsModule, SIGNAL(changed()),
1013 this, SLOT(change_adaptor()));
1016 modulesModule = new UiWidget<Ui::ModulesUi>;
1017 modulesModule->availableLV->header()->setVisible(false);
1019 new ModuleSelectionManager(modulesModule->availableLV,
1020 modulesModule->selectedLV,
1021 modulesModule->addPB, modulesModule->deletePB,
1022 modulesModule->upPB, modulesModule->downPB,
1023 availableModel(), selectedModel(), this);
1024 connect(selectionManager, SIGNAL(updateHook()),
1025 this, SLOT(updateModuleInfo()));
1026 connect(selectionManager, SIGNAL(updateHook()),
1027 this, SLOT(change_adaptor()));
1028 connect(selectionManager, SIGNAL(selectionChanged()),
1029 this, SLOT(modulesChanged()));
1032 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1034 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1035 this, SLOT(change_adaptor()));
1036 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1037 this, SLOT(change_adaptor()));
1038 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1039 this, SLOT(change_adaptor()));
1040 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1041 this, SLOT(change_adaptor()));
1042 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1043 this, SLOT(change_adaptor()));
1044 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1045 this, SLOT(change_adaptor()));
1046 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1047 this, SLOT(change_adaptor()));
1048 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1049 this, SLOT(change_adaptor()));
1050 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1051 this, SLOT(change_adaptor()));
1052 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1053 this, SLOT(change_adaptor()));
1054 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1055 this, SLOT(change_adaptor()));
1056 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1057 this, SLOT(change_adaptor()));
1058 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1059 this, SLOT(change_adaptor()));
1060 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1061 this, SLOT(change_adaptor()));
1062 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1063 this, SLOT(change_adaptor()));
1064 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1065 this, SLOT(change_adaptor()));
1067 for (int i = 0; backref_opts[i][0]; ++i)
1068 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1071 floatModule = new FloatPlacement;
1072 connect(floatModule, SIGNAL(changed()),
1073 this, SLOT(change_adaptor()));
1076 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1077 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1078 this, SLOT(change_adaptor()));
1079 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1080 this, SLOT(change_adaptor()));
1081 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1082 this, SLOT(setListingsMessage()));
1083 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1084 this, SLOT(setListingsMessage()));
1085 listingsModule->listingsTB->setPlainText(
1086 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1088 docPS->addPanel(latexModule, qt_("Document Class"));
1089 docPS->addPanel(masterChildModule, qt_("Child Documents"));
1090 docPS->addPanel(modulesModule, qt_("Modules"));
1091 docPS->addPanel(fontModule, qt_("Fonts"));
1092 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1093 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1094 docPS->addPanel(marginsModule, qt_("Page Margins"));
1095 docPS->addPanel(langModule, qt_("Language"));
1096 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1097 docPS->addPanel(biblioModule, qt_("Bibliography"));
1098 docPS->addPanel(indicesModule, qt_("Indexes"));
1099 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1100 docPS->addPanel(mathsModule, qt_("Math Options"));
1101 docPS->addPanel(floatModule, qt_("Float Placement"));
1102 docPS->addPanel(listingsModule, qt_("Listings"));
1103 docPS->addPanel(bulletsModule, qt_("Bullets"));
1104 docPS->addPanel(branchesModule, qt_("Branches"));
1105 docPS->addPanel(outputModule, qt_("Output"));
1106 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1107 docPS->setCurrentPanel(qt_("Document Class"));
1108 // FIXME: hack to work around resizing bug in Qt >= 4.2
1109 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1110 #if QT_VERSION >= 0x040200
1111 docPS->updateGeometry();
1116 void GuiDocument::showPreamble()
1118 docPS->setCurrentPanel(qt_("LaTeX Preamble"));
1122 void GuiDocument::saveDefaultClicked()
1128 void GuiDocument::useDefaultsClicked()
1134 void GuiDocument::change_adaptor()
1140 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1145 string child = fromqstr(item->text(0));
1149 if (std::find(includeonlys_.begin(),
1150 includeonlys_.end(), child) != includeonlys_.end())
1151 includeonlys_.remove(child);
1153 includeonlys_.push_back(child);
1155 updateIncludeonlys();
1160 QString GuiDocument::validateListingsParameters()
1162 // use a cache here to avoid repeated validation
1163 // of the same parameters
1164 static string param_cache;
1165 static QString msg_cache;
1167 if (listingsModule->bypassCB->isChecked())
1170 string params = fromqstr(listingsModule->listingsED->toPlainText());
1171 if (params != param_cache) {
1172 param_cache = params;
1173 msg_cache = toqstr(InsetListingsParams(params).validate());
1179 void GuiDocument::setListingsMessage()
1181 static bool isOK = true;
1182 QString msg = validateListingsParameters();
1183 if (msg.isEmpty()) {
1187 // listingsTB->setTextColor("black");
1188 listingsModule->listingsTB->setPlainText(
1189 qt_("Input listings parameters below. "
1190 "Enter ? for a list of parameters."));
1193 // listingsTB->setTextColor("red");
1194 listingsModule->listingsTB->setPlainText(msg);
1199 void GuiDocument::setLSpacing(int item)
1201 textLayoutModule->lspacingLE->setEnabled(item == 3);
1205 void GuiDocument::setIndent(int item)
1207 bool const enable = (item == 1);
1208 textLayoutModule->indentLE->setEnabled(enable);
1209 textLayoutModule->indentLengthCO->setEnabled(enable);
1210 textLayoutModule->skipLE->setEnabled(false);
1211 textLayoutModule->skipLengthCO->setEnabled(false);
1216 void GuiDocument::enableIndent(bool indent)
1218 textLayoutModule->skipLE->setEnabled(!indent);
1219 textLayoutModule->skipLengthCO->setEnabled(!indent);
1221 setIndent(textLayoutModule->indentCO->currentIndex());
1225 void GuiDocument::setSkip(int item)
1227 bool const enable = (item == 3);
1228 textLayoutModule->skipLE->setEnabled(enable);
1229 textLayoutModule->skipLengthCO->setEnabled(enable);
1234 void GuiDocument::enableSkip(bool skip)
1236 textLayoutModule->indentLE->setEnabled(!skip);
1237 textLayoutModule->indentLengthCO->setEnabled(!skip);
1239 setSkip(textLayoutModule->skipCO->currentIndex());
1243 void GuiDocument::portraitChanged()
1245 setMargins(pageLayoutModule->papersizeCO->currentIndex());
1249 void GuiDocument::setMargins(bool custom)
1251 bool const extern_geometry =
1252 documentClass().provides("geometry");
1253 marginsModule->marginCB->setEnabled(!extern_geometry);
1254 if (extern_geometry) {
1255 marginsModule->marginCB->setChecked(false);
1256 setCustomMargins(true);
1259 marginsModule->marginCB->setChecked(custom);
1260 setCustomMargins(custom);
1264 void GuiDocument::papersizeChanged(int paper_size)
1266 setCustomPapersize(paper_size == 1);
1270 void GuiDocument::setCustomPapersize(bool custom)
1272 pageLayoutModule->paperwidthL->setEnabled(custom);
1273 pageLayoutModule->paperwidthLE->setEnabled(custom);
1274 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1275 pageLayoutModule->paperheightL->setEnabled(custom);
1276 pageLayoutModule->paperheightLE->setEnabled(custom);
1277 pageLayoutModule->paperheightLE->setFocus();
1278 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1282 void GuiDocument::setColSep()
1284 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1288 void GuiDocument::setCustomMargins(bool custom)
1290 marginsModule->topL->setEnabled(!custom);
1291 marginsModule->topLE->setEnabled(!custom);
1292 marginsModule->topUnit->setEnabled(!custom);
1294 marginsModule->bottomL->setEnabled(!custom);
1295 marginsModule->bottomLE->setEnabled(!custom);
1296 marginsModule->bottomUnit->setEnabled(!custom);
1298 marginsModule->innerL->setEnabled(!custom);
1299 marginsModule->innerLE->setEnabled(!custom);
1300 marginsModule->innerUnit->setEnabled(!custom);
1302 marginsModule->outerL->setEnabled(!custom);
1303 marginsModule->outerLE->setEnabled(!custom);
1304 marginsModule->outerUnit->setEnabled(!custom);
1306 marginsModule->headheightL->setEnabled(!custom);
1307 marginsModule->headheightLE->setEnabled(!custom);
1308 marginsModule->headheightUnit->setEnabled(!custom);
1310 marginsModule->headsepL->setEnabled(!custom);
1311 marginsModule->headsepLE->setEnabled(!custom);
1312 marginsModule->headsepUnit->setEnabled(!custom);
1314 marginsModule->footskipL->setEnabled(!custom);
1315 marginsModule->footskipLE->setEnabled(!custom);
1316 marginsModule->footskipUnit->setEnabled(!custom);
1318 bool const enableColSep = !custom &&
1319 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1320 marginsModule->columnsepL->setEnabled(enableColSep);
1321 marginsModule->columnsepLE->setEnabled(enableColSep);
1322 marginsModule->columnsepUnit->setEnabled(enableColSep);
1325 void GuiDocument::changeBackgroundColor()
1327 QColor const & newColor = QColorDialog::getColor(
1328 rgb2qcolor(set_backgroundcolor), asQWidget());
1329 if (!newColor.isValid())
1331 // set the button color
1332 pageLayoutModule->backgroundPB->setStyleSheet(
1333 colorButtonStyleSheet(newColor));
1335 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1340 void GuiDocument::deleteBackgroundColor()
1342 // set the button color back to white
1343 pageLayoutModule->backgroundPB->setStyleSheet(
1344 colorButtonStyleSheet(QColor(Qt::white)));
1345 // save white as the set color
1346 set_backgroundcolor = rgbFromHexName("#ffffff");
1351 void GuiDocument::xetexChanged(bool xetex)
1354 updateDefaultFormat();
1355 langModule->encodingCO->setEnabled(!xetex &&
1356 !langModule->defaultencodingRB->isChecked());
1357 langModule->defaultencodingRB->setEnabled(!xetex);
1358 langModule->otherencodingRB->setEnabled(!xetex);
1360 fontModule->fontsDefaultCO->setEnabled(!xetex);
1361 fontModule->fontsDefaultLA->setEnabled(!xetex);
1362 fontModule->cjkFontLE->setEnabled(!xetex);
1363 fontModule->cjkFontLA->setEnabled(!xetex);
1366 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1367 bool scaleable = providesScale(font);
1368 fontModule->scaleSansSB->setEnabled(scaleable);
1369 fontModule->scaleSansLA->setEnabled(scaleable);
1371 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1372 scaleable = providesScale(font);
1373 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1374 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1376 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1377 fontModule->fontScCB->setEnabled(providesSC(font));
1378 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1380 fontModule->fontencLA->setEnabled(!xetex);
1381 fontModule->fontencCO->setEnabled(!xetex);
1382 fontModule->fontencLE->setEnabled(!xetex);
1386 void GuiDocument::updateFontsize(string const & items, string const & sel)
1388 fontModule->fontsizeCO->clear();
1389 fontModule->fontsizeCO->addItem(qt_("Default"));
1391 for (int n = 0; !token(items,'|',n).empty(); ++n)
1392 fontModule->fontsizeCO->
1393 addItem(toqstr(token(items,'|',n)));
1395 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1396 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1397 fontModule->fontsizeCO->setCurrentIndex(n);
1404 void GuiDocument::updateFontlist()
1406 fontModule->fontsRomanCO->clear();
1407 fontModule->fontsSansCO->clear();
1408 fontModule->fontsTypewriterCO->clear();
1410 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1411 if (outputModule->xetexCB->isChecked()) {
1412 fontModule->fontsRomanCO->addItem(qt_("Default"));
1413 fontModule->fontsSansCO->addItem(qt_("Default"));
1414 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1416 QFontDatabase fontdb;
1417 QStringList families(fontdb.families());
1418 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1419 fontModule->fontsRomanCO->addItem(*it);
1420 fontModule->fontsSansCO->addItem(*it);
1421 fontModule->fontsTypewriterCO->addItem(*it);
1426 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1427 QString font = qt_(tex_fonts_roman_gui[n]);
1428 if (!isFontAvailable(tex_fonts_roman[n]))
1429 font += qt_(" (not installed)");
1430 fontModule->fontsRomanCO->addItem(font);
1432 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1433 QString font = qt_(tex_fonts_sans_gui[n]);
1434 if (!isFontAvailable(tex_fonts_sans[n]))
1435 font += qt_(" (not installed)");
1436 fontModule->fontsSansCO->addItem(font);
1438 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1439 QString font = qt_(tex_fonts_monospaced_gui[n]);
1440 if (!isFontAvailable(tex_fonts_monospaced[n]))
1441 font += qt_(" (not installed)");
1442 fontModule->fontsTypewriterCO->addItem(font);
1447 void GuiDocument::fontencChanged(int item)
1449 fontModule->fontencLE->setEnabled(item == 1);
1453 void GuiDocument::romanChanged(int item)
1455 if (outputModule->xetexCB->isChecked())
1457 string const font = tex_fonts_roman[item];
1458 fontModule->fontScCB->setEnabled(providesSC(font));
1459 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1463 void GuiDocument::sansChanged(int item)
1465 if (outputModule->xetexCB->isChecked())
1467 string const font = tex_fonts_sans[item];
1468 bool scaleable = providesScale(font);
1469 fontModule->scaleSansSB->setEnabled(scaleable);
1470 fontModule->scaleSansLA->setEnabled(scaleable);
1474 void GuiDocument::ttChanged(int item)
1476 if (outputModule->xetexCB->isChecked())
1478 string const font = tex_fonts_monospaced[item];
1479 bool scaleable = providesScale(font);
1480 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1481 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1485 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1488 pageLayoutModule->pagestyleCO->clear();
1489 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1491 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1492 string style = token(items, '|', n);
1493 QString style_gui = qt_(style);
1494 pagestyles.push_back(pair<string, QString>(style, style_gui));
1495 pageLayoutModule->pagestyleCO->addItem(style_gui);
1498 if (sel == "default") {
1499 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1505 for (size_t i = 0; i < pagestyles.size(); ++i)
1506 if (pagestyles[i].first == sel)
1507 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1510 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1514 void GuiDocument::browseLayout()
1516 QString const label1 = qt_("Layouts|#o#O");
1517 QString const dir1 = toqstr(lyxrc.document_path);
1518 QStringList const filter(qt_("LyX Layout (*.layout)"));
1519 QString file = browseRelFile(QString(), bufferFilepath(),
1520 qt_("Local layout file"), filter, false,
1523 if (!file.endsWith(".layout"))
1526 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1527 fromqstr(bufferFilepath()));
1529 int const ret = Alert::prompt(_("Local layout file"),
1530 _("The layout file you have selected is a local layout\n"
1531 "file, not one in the system or user directory. Your\n"
1532 "document may not work with this layout if you do not\n"
1533 "keep the layout file in the document directory."),
1534 1, 1, _("&Set Layout"), _("&Cancel"));
1538 // load the layout file
1539 LayoutFileList & bcl = LayoutFileList::get();
1540 string classname = layoutFile.onlyFileName();
1541 // this will update an existing layout if that layout has been loaded before.
1542 LayoutFileIndex name = bcl.addLocalLayout(
1543 classname.substr(0, classname.size() - 7),
1544 layoutFile.onlyPath().absFilename());
1547 Alert::error(_("Error"),
1548 _("Unable to read local layout file."));
1552 // do not trigger classChanged if there is no change.
1553 if (latexModule->classCO->currentText() == toqstr(name))
1557 int idx = latexModule->classCO->findText(toqstr(name));
1559 classes_model_.insertRow(0, toqstr(name), name);
1560 latexModule->classCO->setCurrentIndex(0);
1562 latexModule->classCO->setCurrentIndex(idx);
1568 void GuiDocument::browseMaster()
1570 QString const title = qt_("Select master document");
1571 QString const dir1 = toqstr(lyxrc.document_path);
1572 QString const old = latexModule->childDocLE->text();
1573 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1574 QStringList const filter(qt_("LyX Files (*.lyx)"));
1575 QString file = browseRelFile(old, docpath, title, filter, false,
1576 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1578 if (!file.isEmpty())
1579 latexModule->childDocLE->setText(file);
1583 void GuiDocument::classChanged()
1585 int idx = latexModule->classCO->currentIndex();
1588 string const classname = classes_model_.getIDString(idx);
1590 // check whether the selected modules have changed.
1591 bool modules_changed = false;
1592 unsigned int const srows = selectedModel()->rowCount();
1593 if (srows != bp_.getModules().size())
1594 modules_changed = true;
1596 list<string>::const_iterator mit = bp_.getModules().begin();
1597 list<string>::const_iterator men = bp_.getModules().end();
1598 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1599 if (selectedModel()->getIDString(i) != *mit) {
1600 modules_changed = true;
1605 if (modules_changed || lyxrc.auto_reset_options) {
1606 if (applyPB->isEnabled()) {
1607 int const ret = Alert::prompt(_("Unapplied changes"),
1608 _("Some changes in the dialog were not yet applied.\n"
1609 "If you do not apply now, they will be lost after this action."),
1610 1, 1, _("&Apply"), _("&Dismiss"));
1616 // We load the TextClass as soon as it is selected. This is
1617 // necessary so that other options in the dialog can be updated
1618 // according to the new class. Note, however, that, if you use
1619 // the scroll wheel when sitting on the combo box, we'll load a
1620 // lot of TextClass objects very quickly....
1621 if (!bp_.setBaseClass(classname)) {
1622 Alert::error(_("Error"), _("Unable to set document class."));
1625 if (lyxrc.auto_reset_options)
1626 bp_.useClassDefaults();
1628 // With the introduction of modules came a distinction between the base
1629 // class and the document class. The former corresponds to the main layout
1630 // file; the latter is that plus the modules (or the document-specific layout,
1631 // or whatever else there could be). Our parameters come from the document
1632 // class. So when we set the base class, we also need to recreate the document
1633 // class. Otherwise, we still have the old one.
1634 bp_.makeDocumentClass();
1639 void GuiDocument::bibtexChanged(int n)
1641 biblioModule->bibtexOptionsED->setEnabled(n != 0);
1647 // This is an insanely complicated attempt to make this sort of thing
1648 // work with RTL languages.
1649 docstring formatStrVec(vector<string> const & v, docstring const & s)
1651 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1655 return from_utf8(v[0]);
1656 if (v.size() == 2) {
1657 docstring retval = _("%1$s and %2$s");
1658 retval = subst(retval, _("and"), s);
1659 return bformat(retval, from_utf8(v[0]), from_utf8(v[1]));
1661 // The idea here is to format all but the last two items...
1662 int const vSize = v.size();
1663 docstring t2 = _("%1$s, %2$s");
1664 docstring retval = from_utf8(v[0]);
1665 for (int i = 1; i < vSize - 2; ++i)
1666 retval = bformat(t2, retval, from_utf8(v[i]));
1667 //...and then to plug them, and the last two, into this schema
1668 docstring t = _("%1$s, %2$s, and %3$s");
1669 t = subst(t, _("and"), s);
1670 return bformat(t, retval, from_utf8(v[vSize - 2]), from_utf8(v[vSize - 1]));
1673 vector<string> idsToNames(vector<string> const & idList)
1675 vector<string> retval;
1676 vector<string>::const_iterator it = idList.begin();
1677 vector<string>::const_iterator end = idList.end();
1678 for (; it != end; ++it) {
1679 LyXModule const * const mod = theModuleList[*it];
1681 retval.push_back(*it + " (Unavailable)");
1683 retval.push_back(mod->getName());
1690 void GuiDocument::modulesToParams(BufferParams & bp)
1692 // update list of loaded modules
1693 bp.clearLayoutModules();
1694 int const srows = modules_sel_model_.rowCount();
1695 for (int i = 0; i < srows; ++i)
1696 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1698 // update the list of removed modules
1699 bp.clearRemovedModules();
1700 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1701 list<string>::const_iterator rit = reqmods.begin();
1702 list<string>::const_iterator ren = reqmods.end();
1704 // check each of the default modules
1705 for (; rit != ren; rit++) {
1706 list<string>::const_iterator mit = bp.getModules().begin();
1707 list<string>::const_iterator men = bp.getModules().end();
1709 for (; mit != men; mit++) {
1716 // the module isn't present so must have been removed by the user
1717 bp.addRemovedModule(*rit);
1722 void GuiDocument::modulesChanged()
1724 modulesToParams(bp_);
1725 bp_.makeDocumentClass();
1730 void GuiDocument::updateModuleInfo()
1732 selectionManager->update();
1734 //Module description
1735 bool const focus_on_selected = selectionManager->selectedFocused();
1736 QAbstractItemView * lv;
1737 if (focus_on_selected)
1738 lv = modulesModule->selectedLV;
1740 lv= modulesModule->availableLV;
1741 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
1742 modulesModule->infoML->document()->clear();
1745 QModelIndex const & idx = lv->selectionModel()->currentIndex();
1746 GuiIdListModel const & id_model =
1747 focus_on_selected ? modules_sel_model_ : modules_av_model_;
1748 string const modName = id_model.getIDString(idx.row());
1749 docstring desc = getModuleDescription(modName);
1751 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
1752 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
1755 desc += _("Module provided by document class.");
1758 vector<string> pkglist = getPackageList(modName);
1759 docstring pkgdesc = formatStrVec(pkglist, _("and"));
1760 if (!pkgdesc.empty()) {
1763 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
1766 pkglist = getRequiredList(modName);
1767 if (!pkglist.empty()) {
1768 vector<string> const reqdescs = idsToNames(pkglist);
1769 pkgdesc = formatStrVec(reqdescs, _("or"));
1772 desc += bformat(_("Module required: %1$s."), pkgdesc);
1775 pkglist = getExcludedList(modName);
1776 if (!pkglist.empty()) {
1777 vector<string> const reqdescs = idsToNames(pkglist);
1778 pkgdesc = formatStrVec(reqdescs, _( "and"));
1781 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
1784 if (!isModuleAvailable(modName)) {
1787 desc += _("WARNING: Some required packages are unavailable!");
1790 modulesModule->infoML->document()->setPlainText(toqstr(desc));
1794 void GuiDocument::updateNumbering()
1796 DocumentClass const & tclass = documentClass();
1798 numberingModule->tocTW->setUpdatesEnabled(false);
1799 numberingModule->tocTW->clear();
1801 int const depth = numberingModule->depthSL->value();
1802 int const toc = numberingModule->tocSL->value();
1803 QString const no = qt_("No");
1804 QString const yes = qt_("Yes");
1805 QTreeWidgetItem * item = 0;
1807 DocumentClass::const_iterator lit = tclass.begin();
1808 DocumentClass::const_iterator len = tclass.end();
1809 for (; lit != len; ++lit) {
1810 int const toclevel = lit->toclevel;
1811 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
1812 item = new QTreeWidgetItem(numberingModule->tocTW);
1813 item->setText(0, toqstr(translateIfPossible(lit->name())));
1814 item->setText(1, (toclevel <= depth) ? yes : no);
1815 item->setText(2, (toclevel <= toc) ? yes : no);
1819 numberingModule->tocTW->setUpdatesEnabled(true);
1820 numberingModule->tocTW->update();
1824 void GuiDocument::updateDefaultFormat()
1826 // make a copy in order to consider unapplied changes
1827 Buffer * tmpbuf = const_cast<Buffer *>(&buffer());
1828 tmpbuf->params().useXetex = outputModule->xetexCB->isChecked();
1829 int idx = latexModule->classCO->currentIndex();
1831 string const classname = classes_model_.getIDString(idx);
1832 tmpbuf->params().setBaseClass(classname);
1833 tmpbuf->params().makeDocumentClass();
1835 outputModule->defaultFormatCO->blockSignals(true);
1836 outputModule->defaultFormatCO->clear();
1837 outputModule->defaultFormatCO->addItem(qt_("Default"),
1838 QVariant(QString("default")));
1839 typedef vector<Format const *> Formats;
1840 Formats formats = tmpbuf->exportableFormats(true);
1841 Formats::const_iterator cit = formats.begin();
1842 Formats::const_iterator end = formats.end();
1843 for (; cit != end; ++cit)
1844 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
1845 QVariant(toqstr((*cit)->name())));
1846 outputModule->defaultFormatCO->blockSignals(false);
1850 bool GuiDocument::isChildIncluded(string const & child)
1852 if (includeonlys_.empty())
1854 return (std::find(includeonlys_.begin(),
1855 includeonlys_.end(), child) != includeonlys_.end());
1859 void GuiDocument::applyView()
1862 preambleModule->apply(bp_);
1865 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
1868 bp_.setCiteEngine(ENGINE_BASIC);
1870 if (biblioModule->citeNatbibRB->isChecked()) {
1871 bool const use_numerical_citations =
1872 biblioModule->citeStyleCO->currentIndex();
1873 if (use_numerical_citations)
1874 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
1876 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
1878 } else if (biblioModule->citeJurabibRB->isChecked())
1879 bp_.setCiteEngine(ENGINE_JURABIB);
1882 biblioModule->bibtopicCB->isChecked();
1884 string const bibtex_command =
1885 fromqstr(biblioModule->bibtexCO->itemData(
1886 biblioModule->bibtexCO->currentIndex()).toString());
1887 string const bibtex_options =
1888 fromqstr(biblioModule->bibtexOptionsED->text());
1889 if (bibtex_command == "default" || bibtex_options.empty())
1890 bp_.bibtex_command = bibtex_command;
1892 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
1895 indicesModule->apply(bp_);
1897 // language & quotes
1898 if (langModule->defaultencodingRB->isChecked()) {
1899 bp_.inputenc = "auto";
1901 int i = langModule->encodingCO->currentIndex();
1903 bp_.inputenc = "default";
1905 QString const enc_gui =
1906 langModule->encodingCO->currentText();
1907 Encodings::const_iterator it = encodings.begin();
1908 Encodings::const_iterator const end = encodings.end();
1910 for (; it != end; ++it) {
1911 if (qt_(it->guiName()) == enc_gui) {
1912 bp_.inputenc = it->latexName();
1918 // should not happen
1919 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
1920 bp_.inputenc = "default";
1925 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
1926 switch (langModule->quoteStyleCO->currentIndex()) {
1928 lga = InsetQuotes::EnglishQuotes;
1931 lga = InsetQuotes::SwedishQuotes;
1934 lga = InsetQuotes::GermanQuotes;
1937 lga = InsetQuotes::PolishQuotes;
1940 lga = InsetQuotes::FrenchQuotes;
1943 lga = InsetQuotes::DanishQuotes;
1946 bp_.quotes_language = lga;
1948 QString const lang = langModule->languageCO->itemData(
1949 langModule->languageCO->currentIndex()).toString();
1950 bp_.language = lyx::languages.getLanguage(fromqstr(lang));
1953 if (bp_.documentClass().hasTocLevels()) {
1954 bp_.tocdepth = numberingModule->tocSL->value();
1955 bp_.secnumdepth = numberingModule->depthSL->value();
1959 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
1960 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
1961 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
1962 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
1965 bp_.graphicsDriver =
1966 tex_graphics[latexModule->psdriverCO->currentIndex()];
1969 int idx = latexModule->classCO->currentIndex();
1971 string const classname = classes_model_.getIDString(idx);
1972 bp_.setBaseClass(classname);
1976 modulesToParams(bp_);
1979 if (mathsModule->amsautoCB->isChecked()) {
1980 bp_.use_amsmath = BufferParams::package_auto;
1982 if (mathsModule->amsCB->isChecked())
1983 bp_.use_amsmath = BufferParams::package_on;
1985 bp_.use_amsmath = BufferParams::package_off;
1987 if (mathsModule->esintautoCB->isChecked())
1988 bp_.use_esint = BufferParams::package_auto;
1990 if (mathsModule->esintCB->isChecked())
1991 bp_.use_esint = BufferParams::package_on;
1993 bp_.use_esint = BufferParams::package_off;
1995 if (mathsModule->mhchemautoCB->isChecked())
1996 bp_.use_mhchem = BufferParams::package_auto;
1998 if (mathsModule->mhchemCB->isChecked())
1999 bp_.use_mhchem = BufferParams::package_on;
2001 bp_.use_mhchem = BufferParams::package_off;
2005 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2006 bp_.pagestyle = "default";
2008 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2009 for (size_t i = 0; i != pagestyles.size(); ++i)
2010 if (pagestyles[i].second == style_gui)
2011 bp_.pagestyle = pagestyles[i].first;
2015 switch (textLayoutModule->lspacingCO->currentIndex()) {
2017 bp_.spacing().set(Spacing::Single);
2020 bp_.spacing().set(Spacing::Onehalf);
2023 bp_.spacing().set(Spacing::Double);
2026 bp_.spacing().set(Spacing::Other,
2027 widgetToDoubleStr(textLayoutModule->lspacingLE));
2031 if (textLayoutModule->twoColumnCB->isChecked())
2036 if (textLayoutModule->indentRB->isChecked()) {
2037 // if paragraphs are separated by an indentation
2038 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2039 switch (textLayoutModule->indentCO->currentIndex()) {
2041 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2044 HSpace indent = HSpace(
2045 widgetsToLength(textLayoutModule->indentLE,
2046 textLayoutModule->indentLengthCO)
2048 bp_.setIndentation(indent);
2052 // this should never happen
2053 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2057 // if paragraphs are separated by a skip
2058 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2059 switch (textLayoutModule->skipCO->currentIndex()) {
2061 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2064 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2067 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2072 widgetsToLength(textLayoutModule->skipLE,
2073 textLayoutModule->skipLengthCO)
2079 // this should never happen
2080 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2086 fromqstr(latexModule->optionsLE->text());
2088 bp_.use_default_options =
2089 latexModule->defaultOptionsCB->isChecked();
2091 if (latexModule->childDocGB->isChecked())
2093 fromqstr(latexModule->childDocLE->text());
2095 bp_.master = string();
2098 bp_.clearIncludedChildren();
2099 if (masterChildModule->includeonlyRB->isChecked()) {
2100 list<string>::const_iterator it = includeonlys_.begin();
2101 for (; it != includeonlys_.end() ; ++it) {
2102 bp_.addIncludedChildren(*it);
2105 bp_.maintain_unincluded_children =
2106 masterChildModule->maintainAuxCB->isChecked();
2109 bp_.float_placement = floatModule->get();
2112 // text should have passed validation
2113 bp_.listings_params =
2114 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2117 bp_.defaultOutputFormat = fromqstr(outputModule->defaultFormatCO->itemData(
2118 outputModule->defaultFormatCO->currentIndex()).toString());
2120 bool const xetex = outputModule->xetexCB->isChecked();
2121 bp_.useXetex = xetex;
2125 if (fontModule->fontsRomanCO->currentIndex() == 0)
2126 bp_.fontsRoman = "default";
2129 fromqstr(fontModule->fontsRomanCO->currentText());
2131 if (fontModule->fontsSansCO->currentIndex() == 0)
2132 bp_.fontsSans = "default";
2135 fromqstr(fontModule->fontsSansCO->currentText());
2137 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
2138 bp_.fontsTypewriter = "default";
2140 bp_.fontsTypewriter =
2141 fromqstr(fontModule->fontsTypewriterCO->currentText());
2144 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
2147 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
2149 bp_.fontsTypewriter =
2150 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
2153 if (fontModule->fontencCO->currentIndex() == 0)
2154 bp_.fontenc = "global";
2155 else if (fontModule->fontencCO->currentIndex() == 1)
2156 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2157 else if (fontModule->fontencCO->currentIndex() == 2)
2158 bp_.fontenc = "default";
2161 fromqstr(fontModule->cjkFontLE->text());
2163 bp_.fontsSansScale = fontModule->scaleSansSB->value();
2165 bp_.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
2167 bp_.fontsSC = fontModule->fontScCB->isChecked();
2169 bp_.fontsOSF = fontModule->fontOsfCB->isChecked();
2172 bp_.fontsDefaultFamily = "default";
2174 bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
2175 fontModule->fontsDefaultCO->currentIndex()];
2177 if (fontModule->fontsizeCO->currentIndex() == 0)
2178 bp_.fontsize = "default";
2181 fromqstr(fontModule->fontsizeCO->currentText());
2184 bp_.papersize = PAPER_SIZE(
2185 pageLayoutModule->papersizeCO->currentIndex());
2187 // custom, A3, B3 and B4 paper sizes need geometry
2188 int psize = pageLayoutModule->papersizeCO->currentIndex();
2189 bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
2191 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2192 pageLayoutModule->paperwidthUnitCO);
2194 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2195 pageLayoutModule->paperheightUnitCO);
2197 if (pageLayoutModule->facingPagesCB->isChecked())
2198 bp_.sides = TwoSides;
2200 bp_.sides = OneSide;
2202 if (pageLayoutModule->landscapeRB->isChecked())
2203 bp_.orientation = ORIENTATION_LANDSCAPE;
2205 bp_.orientation = ORIENTATION_PORTRAIT;
2207 bp_.backgroundcolor = set_backgroundcolor;
2210 bp_.use_geometry = !marginsModule->marginCB->isChecked()
2213 Ui::MarginsUi const * m = marginsModule;
2215 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2216 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2217 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2218 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2219 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2220 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2221 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2222 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2225 branchesModule->apply(bp_);
2228 PDFOptions & pdf = bp_.pdfoptions();
2229 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2230 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2231 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2232 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2233 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2235 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2236 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2237 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2238 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2240 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2241 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2242 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2243 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2245 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2246 if (pdfSupportModule->fullscreenCB->isChecked())
2247 pdf.pagemode = pdf.pagemode_fullscreen;
2249 pdf.pagemode.clear();
2250 pdf.quoted_options = pdf.quoted_options_check(
2251 fromqstr(pdfSupportModule->optionsLE->text()));
2255 void GuiDocument::paramsToDialog()
2257 // set the default unit
2258 Length::UNIT const defaultUnit = Length::defaultUnit();
2261 preambleModule->update(bp_, id());
2264 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2267 biblioModule->citeDefaultRB->setChecked(
2268 bp_.citeEngine() == ENGINE_BASIC);
2270 biblioModule->citeNatbibRB->setChecked(
2271 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2272 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2274 biblioModule->citeStyleCO->setCurrentIndex(
2275 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2277 biblioModule->citeJurabibRB->setChecked(
2278 bp_.citeEngine() == ENGINE_JURABIB);
2280 biblioModule->bibtopicCB->setChecked(
2285 split(bp_.bibtex_command, command, ' ');
2287 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2289 biblioModule->bibtexCO->setCurrentIndex(bpos);
2290 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2292 biblioModule->bibtexCO->setCurrentIndex(0);
2293 biblioModule->bibtexOptionsED->clear();
2295 biblioModule->bibtexOptionsED->setEnabled(
2296 biblioModule->bibtexCO->currentIndex() != 0);
2299 indicesModule->update(bp_);
2301 // language & quotes
2302 int const pos = langModule->languageCO->findData(toqstr(
2303 bp_.language->lang()));
2304 langModule->languageCO->setCurrentIndex(pos);
2306 langModule->quoteStyleCO->setCurrentIndex(
2307 bp_.quotes_language);
2309 bool default_enc = true;
2310 if (bp_.inputenc != "auto") {
2311 default_enc = false;
2312 if (bp_.inputenc == "default") {
2313 langModule->encodingCO->setCurrentIndex(0);
2316 Encodings::const_iterator it = encodings.begin();
2317 Encodings::const_iterator const end = encodings.end();
2318 for (; it != end; ++it) {
2319 if (it->latexName() == bp_.inputenc) {
2320 enc_gui = it->guiName();
2324 int const i = langModule->encodingCO->findText(
2327 langModule->encodingCO->setCurrentIndex(i);
2329 // unknown encoding. Set to default.
2333 langModule->defaultencodingRB->setChecked(default_enc);
2334 langModule->otherencodingRB->setChecked(!default_enc);
2337 int const min_toclevel = documentClass().min_toclevel();
2338 int const max_toclevel = documentClass().max_toclevel();
2339 if (documentClass().hasTocLevels()) {
2340 numberingModule->setEnabled(true);
2341 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2342 numberingModule->depthSL->setMaximum(max_toclevel);
2343 numberingModule->depthSL->setValue(bp_.secnumdepth);
2344 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2345 numberingModule->tocSL->setMaximum(max_toclevel);
2346 numberingModule->tocSL->setValue(bp_.tocdepth);
2349 numberingModule->setEnabled(false);
2350 numberingModule->tocTW->clear();
2354 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2355 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2356 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2357 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2358 bulletsModule->init();
2361 int nitem = findToken(tex_graphics, bp_.graphicsDriver);
2363 latexModule->psdriverCO->setCurrentIndex(nitem);
2366 mathsModule->amsCB->setChecked(
2367 bp_.use_amsmath == BufferParams::package_on);
2368 mathsModule->amsautoCB->setChecked(
2369 bp_.use_amsmath == BufferParams::package_auto);
2371 mathsModule->esintCB->setChecked(
2372 bp_.use_esint == BufferParams::package_on);
2373 mathsModule->esintautoCB->setChecked(
2374 bp_.use_esint == BufferParams::package_auto);
2376 mathsModule->mhchemCB->setChecked(
2377 bp_.use_mhchem == BufferParams::package_on);
2378 mathsModule->mhchemautoCB->setChecked(
2379 bp_.use_mhchem == BufferParams::package_auto);
2381 switch (bp_.spacing().getSpace()) {
2382 case Spacing::Other: nitem = 3; break;
2383 case Spacing::Double: nitem = 2; break;
2384 case Spacing::Onehalf: nitem = 1; break;
2385 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2389 string const & layoutID = bp_.baseClassID();
2390 setLayoutComboByIDString(layoutID);
2392 updatePagestyle(documentClass().opt_pagestyle(),
2395 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2396 if (bp_.spacing().getSpace() == Spacing::Other) {
2397 doubleToWidget(textLayoutModule->lspacingLE,
2398 bp_.spacing().getValueAsString());
2402 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2403 textLayoutModule->indentRB->setChecked(true);
2404 string indentation = bp_.getIndentation().asLyXCommand();
2406 if (indentation != "default") {
2407 lengthToWidgets(textLayoutModule->indentLE,
2408 textLayoutModule->indentLengthCO,
2409 indentation, defaultUnit);
2412 textLayoutModule->indentCO->setCurrentIndex(indent);
2415 textLayoutModule->skipRB->setChecked(true);
2417 switch (bp_.getDefSkip().kind()) {
2418 case VSpace::SMALLSKIP:
2421 case VSpace::MEDSKIP:
2424 case VSpace::BIGSKIP:
2427 case VSpace::LENGTH:
2430 string const length = bp_.getDefSkip().asLyXCommand();
2431 lengthToWidgets(textLayoutModule->skipLE,
2432 textLayoutModule->skipLengthCO,
2433 length, defaultUnit);
2440 textLayoutModule->skipCO->setCurrentIndex(skip);
2444 textLayoutModule->twoColumnCB->setChecked(
2447 if (!bp_.options.empty()) {
2448 latexModule->optionsLE->setText(
2449 toqstr(bp_.options));
2451 latexModule->optionsLE->setText(QString());
2455 latexModule->defaultOptionsCB->setChecked(
2456 bp_.use_default_options);
2457 updateSelectedModules();
2458 selectionManager->updateProvidedModules(
2459 bp_.baseClass()->providedModules());
2460 selectionManager->updateExcludedModules(
2461 bp_.baseClass()->excludedModules());
2463 if (!documentClass().options().empty()) {
2464 latexModule->defaultOptionsLE->setText(
2465 toqstr(documentClass().options()));
2467 latexModule->defaultOptionsLE->setText(
2468 toqstr(_("[No options predefined]")));
2471 latexModule->defaultOptionsLE->setEnabled(
2472 bp_.use_default_options
2473 && !documentClass().options().empty());
2475 latexModule->defaultOptionsCB->setEnabled(
2476 !documentClass().options().empty());
2478 if (!bp_.master.empty()) {
2479 latexModule->childDocGB->setChecked(true);
2480 latexModule->childDocLE->setText(
2481 toqstr(bp_.master));
2483 latexModule->childDocLE->setText(QString());
2484 latexModule->childDocGB->setChecked(false);
2488 std::vector<Buffer *> children = buffer().getChildren(false);
2489 if (children.empty()) {
2490 masterChildModule->childrenTW->clear();
2491 includeonlys_.clear();
2492 docPS->showPanel(qt_("Child Documents"), false);
2493 if (docPS->isCurrentPanel(qt_("Child Documents")))
2494 docPS->setCurrentPanel(qt_("Document Class"));
2496 docPS->showPanel(qt_("Child Documents"), true);
2497 masterChildModule->setEnabled(true);
2498 includeonlys_ = bp_.getIncludedChildren();
2499 updateIncludeonlys();
2501 masterChildModule->maintainAuxCB->setChecked(
2502 bp_.maintain_unincluded_children);
2505 floatModule->set(bp_.float_placement);
2508 // break listings_params to multiple lines
2510 InsetListingsParams(bp_.listings_params).separatedParams();
2511 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2514 // update combobox with formats
2515 updateDefaultFormat();
2516 int index = outputModule->defaultFormatCO->findData(toqstr(
2517 bp_.defaultOutputFormat));
2518 // set to default if format is not found
2521 outputModule->defaultFormatCO->setCurrentIndex(index);
2522 outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
2523 outputModule->xetexCB->setChecked(
2524 bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
2527 updateFontsize(documentClass().opt_fontsize(),
2531 fontModule->fontencLA->setEnabled(false);
2532 fontModule->fontencCO->setEnabled(false);
2533 fontModule->fontencLE->setEnabled(false);
2534 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2535 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
2536 fontModule->fontsRomanCO->setCurrentIndex(i);
2541 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2542 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
2543 fontModule->fontsSansCO->setCurrentIndex(i);
2547 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2548 if (fontModule->fontsTypewriterCO->itemText(i) ==
2549 toqstr(bp_.fontsTypewriter)) {
2550 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2555 fontModule->fontencLA->setEnabled(true);
2556 fontModule->fontencCO->setEnabled(true);
2557 fontModule->fontencLE->setEnabled(true);
2558 int n = findToken(tex_fonts_roman, bp_.fontsRoman);
2560 fontModule->fontsRomanCO->setCurrentIndex(n);
2564 n = findToken(tex_fonts_sans, bp_.fontsSans);
2566 fontModule->fontsSansCO->setCurrentIndex(n);
2570 n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
2572 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2577 if (!bp_.fontsCJK.empty())
2578 fontModule->cjkFontLE->setText(
2579 toqstr(bp_.fontsCJK));
2581 fontModule->cjkFontLE->setText(QString());
2583 fontModule->fontScCB->setChecked(bp_.fontsSC);
2584 fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
2585 fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
2586 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
2588 int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
2590 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2592 if (bp_.fontenc == "global")
2593 fontModule->fontencCO->setCurrentIndex(0);
2594 else if (bp_.fontenc == "default")
2595 fontModule->fontencCO->setCurrentIndex(2);
2597 fontModule->fontencCO->setCurrentIndex(1);
2598 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2602 bool const extern_geometry =
2603 documentClass().provides("geometry");
2604 int const psize = bp_.papersize;
2605 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2606 setCustomPapersize(!extern_geometry && psize == 1);
2607 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2609 bool const landscape =
2610 bp_.orientation == ORIENTATION_LANDSCAPE;
2611 pageLayoutModule->landscapeRB->setChecked(landscape);
2612 pageLayoutModule->portraitRB->setChecked(!landscape);
2613 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2614 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2616 pageLayoutModule->facingPagesCB->setChecked(
2617 bp_.sides == TwoSides);
2619 pageLayoutModule->backgroundPB->setStyleSheet(
2620 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2621 set_backgroundcolor = bp_.backgroundcolor;
2623 lengthToWidgets(pageLayoutModule->paperwidthLE,
2624 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2625 lengthToWidgets(pageLayoutModule->paperheightLE,
2626 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2629 Ui::MarginsUi * m = marginsModule;
2631 setMargins(!bp_.use_geometry);
2633 lengthToWidgets(m->topLE, m->topUnit,
2634 bp_.topmargin, defaultUnit);
2636 lengthToWidgets(m->bottomLE, m->bottomUnit,
2637 bp_.bottommargin, defaultUnit);
2639 lengthToWidgets(m->innerLE, m->innerUnit,
2640 bp_.leftmargin, defaultUnit);
2642 lengthToWidgets(m->outerLE, m->outerUnit,
2643 bp_.rightmargin, defaultUnit);
2645 lengthToWidgets(m->headheightLE, m->headheightUnit,
2646 bp_.headheight, defaultUnit);
2648 lengthToWidgets(m->headsepLE, m->headsepUnit,
2649 bp_.headsep, defaultUnit);
2651 lengthToWidgets(m->footskipLE, m->footskipUnit,
2652 bp_.footskip, defaultUnit);
2654 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2655 bp_.columnsep, defaultUnit);
2658 updateUnknownBranches();
2659 branchesModule->update(bp_);
2662 PDFOptions const & pdf = bp_.pdfoptions();
2663 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2664 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2665 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2666 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2667 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2669 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2670 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2671 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2673 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2675 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2676 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2677 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2678 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2680 nn = findToken(backref_opts, pdf.backref);
2682 pdfSupportModule->backrefCO->setCurrentIndex(nn);
2684 pdfSupportModule->fullscreenCB->setChecked
2685 (pdf.pagemode == pdf.pagemode_fullscreen);
2687 pdfSupportModule->optionsLE->setText(
2688 toqstr(pdf.quoted_options));
2690 // Make sure that the bc is in the INITIAL state
2691 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
2694 // clear changed branches cache
2695 changedBranches_.clear();
2699 void GuiDocument::saveDocDefault()
2701 // we have to apply the params first
2707 void GuiDocument::updateAvailableModules()
2709 modules_av_model_.clear();
2710 list<modInfoStruct> const & modInfoList = getModuleInfo();
2711 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
2712 list<modInfoStruct>::const_iterator men = modInfoList.end();
2713 for (int i = 0; mit != men; ++mit, ++i)
2714 modules_av_model_.insertRow(i, mit->name, mit->id,
2719 void GuiDocument::updateSelectedModules()
2721 modules_sel_model_.clear();
2722 list<modInfoStruct> const selModList = getSelectedModules();
2723 list<modInfoStruct>::const_iterator mit = selModList.begin();
2724 list<modInfoStruct>::const_iterator men = selModList.end();
2725 for (int i = 0; mit != men; ++mit, ++i)
2726 modules_sel_model_.insertRow(i, mit->name, mit->id,
2731 void GuiDocument::updateIncludeonlys()
2733 masterChildModule->childrenTW->clear();
2734 QString const no = qt_("No");
2735 QString const yes = qt_("Yes");
2737 if (includeonlys_.empty()) {
2738 masterChildModule->includeallRB->setChecked(true);
2739 masterChildModule->childrenTW->setEnabled(false);
2740 masterChildModule->maintainAuxCB->setEnabled(false);
2742 masterChildModule->includeonlyRB->setChecked(true);
2743 masterChildModule->childrenTW->setEnabled(true);
2744 masterChildModule->maintainAuxCB->setEnabled(true);
2746 QTreeWidgetItem * item = 0;
2747 std::vector<Buffer *> children = buffer().getChildren(false);
2748 vector<Buffer *>::const_iterator it = children.begin();
2749 vector<Buffer *>::const_iterator end = children.end();
2750 bool has_unincluded = false;
2751 bool all_unincluded = true;
2752 for (; it != end; ++it) {
2753 item = new QTreeWidgetItem(masterChildModule->childrenTW);
2756 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFilename()),
2757 from_utf8(buffer().filePath())));
2758 item->setText(0, toqstr(name));
2759 item->setText(1, isChildIncluded(name) ? yes : no);
2760 if (!isChildIncluded(name))
2761 has_unincluded = true;
2763 all_unincluded = false;
2765 // Both if all childs are included and if none is included
2766 // is equal to "include all" (i.e., ommit \includeonly).
2767 // Thus, reset the GUI.
2768 if (!has_unincluded || all_unincluded) {
2769 masterChildModule->includeallRB->setChecked(true);
2770 masterChildModule->childrenTW->setEnabled(false);
2771 includeonlys_.clear();
2773 // If all are included, we need to update again.
2774 if (!has_unincluded)
2775 updateIncludeonlys();
2779 void GuiDocument::updateContents()
2781 // Nothing to do here as the document settings is not cursor dependant.
2786 void GuiDocument::useClassDefaults()
2788 if (applyPB->isEnabled()) {
2789 int const ret = Alert::prompt(_("Unapplied changes"),
2790 _("Some changes in the dialog were not yet applied.\n"
2791 "If you do not apply now, they will be lost after this action."),
2792 1, 1, _("&Apply"), _("&Dismiss"));
2797 int idx = latexModule->classCO->currentIndex();
2798 string const classname = classes_model_.getIDString(idx);
2799 if (!bp_.setBaseClass(classname)) {
2800 Alert::error(_("Error"), _("Unable to set document class."));
2803 bp_.useClassDefaults();
2808 void GuiDocument::setLayoutComboByIDString(string const & idString)
2810 int idx = classes_model_.findIDString(idString);
2812 Alert::warning(_("Can't set layout!"),
2813 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2815 latexModule->classCO->setCurrentIndex(idx);
2819 bool GuiDocument::isValid()
2821 return validateListingsParameters().isEmpty()
2822 && (textLayoutModule->skipCO->currentIndex() != 3
2823 || !textLayoutModule->skipLE->text().isEmpty()
2824 || textLayoutModule->indentRB->isChecked())
2825 && (textLayoutModule->indentCO->currentIndex() != 1
2826 || !textLayoutModule->indentLE->text().isEmpty()
2827 || textLayoutModule->skipRB->isChecked());
2831 char const * const GuiDocument::fontfamilies[5] = {
2832 "default", "rmdefault", "sfdefault", "ttdefault", ""
2836 char const * GuiDocument::fontfamilies_gui[5] = {
2837 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2841 bool GuiDocument::initialiseParams(string const &)
2843 BufferView const * view = bufferview();
2845 bp_ = BufferParams();
2849 bp_ = view->buffer().params();
2851 updateAvailableModules();
2852 //FIXME It'd be nice to make sure here that the selected
2853 //modules are consistent: That required modules are actually
2854 //selected, and that we don't have conflicts. If so, we could
2855 //at least pop up a warning.
2861 void GuiDocument::clearParams()
2863 bp_ = BufferParams();
2867 BufferId GuiDocument::id() const
2869 BufferView const * const view = bufferview();
2870 return view? &view->buffer() : 0;
2874 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2876 return moduleNames_;
2880 list<GuiDocument::modInfoStruct> const
2881 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
2883 LayoutModuleList::const_iterator it = mods.begin();
2884 LayoutModuleList::const_iterator end = mods.end();
2885 list<modInfoStruct> mInfo;
2886 for (; it != end; ++it) {
2889 LyXModule const * const mod = theModuleList[*it];
2892 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
2894 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
2901 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2903 return makeModuleInfo(params().getModules());
2907 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
2909 return makeModuleInfo(params().baseClass()->providedModules());
2913 DocumentClass const & GuiDocument::documentClass() const
2915 return bp_.documentClass();
2919 static void dispatch_bufferparams(Dialog const & dialog,
2920 BufferParams const & bp, FuncCode lfun)
2923 ss << "\\begin_header\n";
2925 ss << "\\end_header\n";
2926 dialog.dispatch(FuncRequest(lfun, ss.str()));
2930 void GuiDocument::dispatchParams()
2932 // This must come first so that a language change is correctly noticed
2935 // Apply the BufferParams. Note that this will set the base class
2936 // and then update the buffer's layout.
2937 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2939 if (!params().master.empty()) {
2940 FileName const master_file = support::makeAbsPath(params().master,
2941 support::onlyPath(buffer().absFileName()));
2942 if (isLyXFilename(master_file.absFilename())) {
2943 Buffer * master = checkAndLoadLyXFile(master_file);
2945 if (master->isChild(const_cast<Buffer *>(&buffer())))
2946 const_cast<Buffer &>(buffer()).setParent(master);
2948 Alert::warning(_("Assigned master does not include this file"),
2949 bformat(_("You must include this file in the document\n"
2950 "'%1$s' in order to use the master document\n"
2951 "feature."), from_utf8(params().master)));
2953 Alert::warning(_("Could not load master"),
2954 bformat(_("The master document '%1$s'\n"
2955 "could not be loaded."),
2956 from_utf8(params().master)));
2960 // Generate the colours requested by each new branch.
2961 BranchList & branchlist = params().branchlist();
2962 if (!branchlist.empty()) {
2963 BranchList::const_iterator it = branchlist.begin();
2964 BranchList::const_iterator const end = branchlist.end();
2965 for (; it != end; ++it) {
2966 docstring const & current_branch = it->branch();
2967 Branch const * branch = branchlist.find(current_branch);
2968 string const x11hexname = X11hexname(branch->color());
2969 // display the new color
2970 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2971 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2974 // Open insets of selected branches, close deselected ones
2975 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2978 // rename branches in the document
2979 executeBranchRenaming();
2980 // and clear changed branches cache
2981 changedBranches_.clear();
2983 // Generate the colours requested by indices.
2984 IndicesList & indiceslist = params().indiceslist();
2985 if (!indiceslist.empty()) {
2986 IndicesList::const_iterator it = indiceslist.begin();
2987 IndicesList::const_iterator const end = indiceslist.end();
2988 for (; it != end; ++it) {
2989 docstring const & current_index = it->shortcut();
2990 Index const * index = indiceslist.findShortcut(current_index);
2991 string const x11hexname = X11hexname(index->color());
2992 // display the new color
2993 docstring const str = current_index + ' ' + from_ascii(x11hexname);
2994 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2997 // FIXME: If we used an LFUN, we would not need those two lines:
2998 BufferView * bv = const_cast<BufferView *>(bufferview());
2999 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3003 void GuiDocument::setLanguage() const
3005 Language const * const newL = bp_.language;
3006 if (buffer().params().language == newL)
3009 string const & lang_name = newL->lang();
3010 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3014 void GuiDocument::saveAsDefault() const
3016 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3020 bool GuiDocument::isFontAvailable(string const & font) const
3022 if (font == "default" || font == "cmr"
3023 || font == "cmss" || font == "cmtt")
3024 // these are standard
3026 if (font == "lmodern" || font == "lmss" || font == "lmtt")
3027 return LaTeXFeatures::isAvailable("lmodern");
3028 if (font == "times" || font == "palatino"
3029 || font == "helvet" || font == "courier")
3030 return LaTeXFeatures::isAvailable("psnfss");
3031 if (font == "cmbr" || font == "cmtl")
3032 return LaTeXFeatures::isAvailable("cmbright");
3033 if (font == "utopia")
3034 return LaTeXFeatures::isAvailable("utopia")
3035 || LaTeXFeatures::isAvailable("fourier");
3036 if (font == "beraserif" || font == "berasans"
3037 || font == "beramono")
3038 return LaTeXFeatures::isAvailable("bera");
3039 return LaTeXFeatures::isAvailable(font);
3043 bool GuiDocument::providesOSF(string const & font) const
3045 if (outputModule->xetexCB->isChecked())
3046 // FIXME: we should check if the fonts really
3047 // have OSF support. But how?
3050 return isFontAvailable("eco");
3051 if (font == "palatino")
3052 return isFontAvailable("mathpazo");
3057 bool GuiDocument::providesSC(string const & font) const
3059 if (outputModule->xetexCB->isChecked())
3061 if (font == "palatino")
3062 return isFontAvailable("mathpazo");
3063 if (font == "utopia")
3064 return isFontAvailable("fourier");
3069 bool GuiDocument::providesScale(string const & font) const
3071 if (outputModule->xetexCB->isChecked())
3073 return font == "helvet" || font == "luximono"
3074 || font == "berasans" || font == "beramono";
3078 void GuiDocument::loadModuleInfo()
3080 moduleNames_.clear();
3081 LyXModuleList::const_iterator it = theModuleList.begin();
3082 LyXModuleList::const_iterator end = theModuleList.end();
3083 for (; it != end; ++it) {
3087 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3088 // this is supposed to give us the first sentence of the description
3091 toqstr(translateIfPossible(from_utf8(it->getDescription())));
3092 int const pos = desc.indexOf(".");
3094 desc.truncate(pos + 1);
3095 m.description = desc;
3096 moduleNames_.push_back(m);
3101 void GuiDocument::updateUnknownBranches()
3103 list<docstring> used_branches;
3104 buffer().getUsedBranches(used_branches);
3105 list<docstring>::const_iterator it = used_branches.begin();
3106 QStringList unknown_branches;
3107 for (; it != used_branches.end() ; ++it) {
3108 if (!buffer().params().branchlist().find(*it))
3109 unknown_branches.append(toqstr(*it));
3111 branchesModule->setUnknownBranches(unknown_branches);
3115 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3117 map<docstring, docstring>::iterator it = changedBranches_.begin();
3118 for (; it != changedBranches_.end() ; ++it) {
3119 if (it->second == oldname) {
3120 // branch has already been renamed
3121 it->second = newname;
3126 changedBranches_[oldname] = newname;
3130 void GuiDocument::executeBranchRenaming() const
3132 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3133 for (; it != changedBranches_.end() ; ++it) {
3134 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3135 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3140 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3143 } // namespace frontend
3146 #include "moc_GuiDocument.cpp"