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>
62 #include <QColorDialog>
63 #include <QCloseEvent>
64 #include <QFontDatabase>
66 #include <QTextCursor>
76 // a style sheet for buttons
77 // this is for example used for the background color setting button
78 static inline QString colorButtonStyleSheet(QColor const & bgColor)
80 if (bgColor.isValid()) {
81 QString rc = QLatin1String("background:");
90 using namespace lyx::support;
95 char const * const tex_graphics[] =
97 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
98 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
99 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
100 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
105 char const * const tex_graphics_gui[] =
107 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
108 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
109 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
110 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
111 "XeTeX", N_("None"), ""
115 char const * const tex_fonts_roman[] =
117 "default", "cmr", "lmodern", "ae", "times", "palatino",
118 "charter", "newcent", "bookman", "utopia", "beraserif",
119 "ccfonts", "chancery", ""
123 char const * tex_fonts_roman_gui[] =
125 N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
126 N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
127 N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
128 N_("Utopia"), N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
133 char const * const tex_fonts_sans[] =
135 "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
139 char const * tex_fonts_sans_gui[] =
141 N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
142 N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
146 char const * const tex_fonts_monospaced[] =
148 "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
152 char const * tex_fonts_monospaced_gui[] =
154 N_("Default"), N_("Computer Modern Typewriter"),
155 N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
156 N_("LuxiMono"), N_("CM Typewriter Light"), ""
160 char const * backref_opts[] =
162 "false", "section", "slide", "page", ""
166 char const * backref_opts_gui[] =
168 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
172 vector<pair<string, QString> > pagestyles;
175 } // anonymous namespace
179 RGBColor set_backgroundcolor;
182 // used when sorting the textclass list.
183 class less_textclass_avail_desc
184 : public binary_function<string, string, int>
187 bool operator()(string const & lhs, string const & rhs) const
189 // Ordering criteria:
190 // 1. Availability of text class
191 // 2. Description (lexicographic)
192 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
193 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
194 int const order = compare_no_case(
195 translateIfPossible(from_utf8(tc1.description())),
196 translateIfPossible(from_utf8(tc2.description())));
197 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
198 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
207 vector<string> getRequiredList(string const & modName)
209 LyXModule const * const mod = theModuleList[modName];
211 return vector<string>(); //empty such thing
212 return mod->getRequiredModules();
216 vector<string> getExcludedList(string const & modName)
218 LyXModule const * const mod = theModuleList[modName];
220 return vector<string>(); //empty such thing
221 return mod->getExcludedModules();
225 docstring getModuleDescription(string const & modName)
227 LyXModule const * const mod = theModuleList[modName];
229 return _("Module not found!");
231 return translateIfPossible(from_utf8(mod->getDescription()));
235 vector<string> getPackageList(string const & modName)
237 LyXModule const * const mod = theModuleList[modName];
239 return vector<string>(); //empty such thing
240 return mod->getPackageList();
244 bool isModuleAvailable(string const & modName)
246 LyXModule const * const mod = theModuleList[modName];
249 return mod->isAvailable();
252 } // anonymous namespace
255 /////////////////////////////////////////////////////////////////////
257 // ModuleSelectionManager
259 /////////////////////////////////////////////////////////////////////
261 /// SelectionManager for use with modules
262 class ModuleSelectionManager : public GuiSelectionManager
266 ModuleSelectionManager(
267 QTreeView * availableLV,
268 QListView * selectedLV,
272 QPushButton * downPB,
273 GuiIdListModel * availableModel,
274 GuiIdListModel * selectedModel,
275 GuiDocument const * container)
276 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
277 upPB, downPB, availableModel, selectedModel), container_(container)
280 void updateProvidedModules(LayoutModuleList const & pm)
281 { provided_modules_ = pm.list(); }
283 void updateExcludedModules(LayoutModuleList const & em)
284 { excluded_modules_ = em.list(); }
287 virtual void updateAddPB();
289 virtual void updateUpPB();
291 virtual void updateDownPB();
293 virtual void updateDelPB();
294 /// returns availableModel as a GuiIdListModel
295 GuiIdListModel * getAvailableModel()
297 return dynamic_cast<GuiIdListModel *>(availableModel);
299 /// returns selectedModel as a GuiIdListModel
300 GuiIdListModel * getSelectedModel()
302 return dynamic_cast<GuiIdListModel *>(selectedModel);
304 /// keeps a list of the modules the text class provides
305 std::list<std::string> provided_modules_;
307 std::list<std::string> excluded_modules_;
309 GuiDocument const * container_;
312 void ModuleSelectionManager::updateAddPB()
314 int const arows = availableModel->rowCount();
315 QModelIndexList const avail_sels =
316 availableLV->selectionModel()->selectedIndexes();
318 // disable if there aren't any modules (?), if none of them is chosen
319 // in the dialog, or if the chosen one is already selected for use.
320 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
321 addPB->setEnabled(false);
325 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
326 string const modname = getAvailableModel()->getIDString(idx.row());
329 container_->params().moduleCanBeAdded(modname);
330 addPB->setEnabled(enable);
334 void ModuleSelectionManager::updateDownPB()
336 int const srows = selectedModel->rowCount();
338 downPB->setEnabled(false);
341 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
342 int const curRow = curidx.row();
343 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
344 downPB->setEnabled(false);
348 // determine whether immediately succeding element requires this one
349 string const curmodname = getSelectedModel()->getIDString(curRow);
350 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
352 vector<string> reqs = getRequiredList(nextmodname);
354 // if it doesn't require anything....
356 downPB->setEnabled(true);
360 // Enable it if this module isn't required.
361 // FIXME This should perhaps be more flexible and check whether, even
362 // if the next one is required, there is also an earlier one that will do.
364 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
367 void ModuleSelectionManager::updateUpPB()
369 int const srows = selectedModel->rowCount();
371 upPB->setEnabled(false);
375 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
376 int curRow = curIdx.row();
377 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
378 upPB->setEnabled(false);
381 string const curmodname = getSelectedModel()->getIDString(curRow);
383 // determine whether immediately preceding element is required by this one
384 vector<string> reqs = getRequiredList(curmodname);
386 // if this one doesn't require anything....
388 upPB->setEnabled(true);
393 // Enable it if the preceding module isn't required.
394 // NOTE This is less flexible than it might be. We could check whether, even
395 // if the previous one is required, there is an earlier one that would do.
396 string const premod = getSelectedModel()->getIDString(curRow - 1);
397 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
400 void ModuleSelectionManager::updateDelPB()
402 int const srows = selectedModel->rowCount();
404 deletePB->setEnabled(false);
408 QModelIndex const & curidx =
409 selectedLV->selectionModel()->currentIndex();
410 int const curRow = curidx.row();
411 if (curRow < 0 || curRow >= srows) { // invalid index?
412 deletePB->setEnabled(false);
416 string const curmodname = getSelectedModel()->getIDString(curRow);
418 // We're looking here for a reason NOT to enable the button. If we
419 // find one, we disable it and return. If we don't, we'll end up at
420 // the end of the function, and then we enable it.
421 for (int i = curRow + 1; i < srows; ++i) {
422 string const thisMod = getSelectedModel()->getIDString(i);
423 vector<string> reqs = getRequiredList(thisMod);
424 //does this one require us?
425 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
429 // OK, so this module requires us
430 // is there an EARLIER module that also satisfies the require?
431 // NOTE We demand that it be earlier to keep the list of modules
432 // consistent with the rule that a module must be proceeded by a
433 // required module. There would be more flexible ways to proceed,
434 // but that would be a lot more complicated, and the logic here is
435 // already complicated. (That's why I've left the debugging code.)
436 // lyxerr << "Testing " << thisMod << std::endl;
437 bool foundone = false;
438 for (int j = 0; j < curRow; ++j) {
439 string const mod = getSelectedModel()->getIDString(j);
440 // lyxerr << "In loop: Testing " << mod << std::endl;
441 // do we satisfy the require?
442 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
443 // lyxerr << mod << " does the trick." << std::endl;
448 // did we find a module to satisfy the require?
450 // lyxerr << "No matching module found." << std::endl;
451 deletePB->setEnabled(false);
455 // lyxerr << "All's well that ends well." << std::endl;
456 deletePB->setEnabled(true);
460 /////////////////////////////////////////////////////////////////////
464 /////////////////////////////////////////////////////////////////////
466 PreambleModule::PreambleModule() : current_id_(0)
468 // This is not a memory leak. The object will be destroyed
470 (void) new LaTeXHighlighter(preambleTE->document());
471 setFocusProxy(preambleTE);
472 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
476 void PreambleModule::update(BufferParams const & params, BufferId id)
478 QString preamble = toqstr(params.preamble);
479 // Nothing to do if the params and preamble are unchanged.
480 if (id == current_id_
481 && preamble == preambleTE->document()->toPlainText())
484 QTextCursor cur = preambleTE->textCursor();
485 // Save the coords before switching to the new one.
486 preamble_coords_[current_id_] =
487 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
489 // Save the params address for further use.
491 preambleTE->document()->setPlainText(preamble);
492 Coords::const_iterator it = preamble_coords_.find(current_id_);
493 if (it == preamble_coords_.end())
494 // First time we open this one.
495 preamble_coords_[current_id_] = make_pair(0, 0);
497 // Restore saved coords.
498 QTextCursor cur = preambleTE->textCursor();
499 cur.setPosition(it->second.first);
500 preambleTE->setTextCursor(cur);
501 preambleTE->verticalScrollBar()->setValue(it->second.second);
506 void PreambleModule::apply(BufferParams & params)
508 params.preamble = fromqstr(preambleTE->document()->toPlainText());
512 void PreambleModule::closeEvent(QCloseEvent * e)
514 // Save the coords before closing.
515 QTextCursor cur = preambleTE->textCursor();
516 preamble_coords_[current_id_] =
517 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
522 /////////////////////////////////////////////////////////////////////
526 /////////////////////////////////////////////////////////////////////
529 GuiDocument::GuiDocument(GuiView & lv)
530 : GuiDialog(lv, "document", qt_("Document Settings"))
534 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
535 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
536 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
537 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
539 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
540 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
542 // Manage the restore, ok, apply, restore and cancel/close buttons
543 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
545 bc().setApply(applyPB);
546 bc().setCancel(closePB);
547 bc().setRestore(restorePB);
549 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
551 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
552 this, SLOT(change_adaptor()));
553 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
554 this, SLOT(setLSpacing(int)));
555 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
556 this, SLOT(change_adaptor()));
558 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
559 this, SLOT(change_adaptor()));
560 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
561 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
562 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
563 this, SLOT(change_adaptor()));
564 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
565 this, SLOT(setIndent(int)));
566 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
567 this, SLOT(change_adaptor()));
568 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
569 this, SLOT(change_adaptor()));
571 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
572 this, SLOT(change_adaptor()));
573 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
574 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
575 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
576 this, SLOT(change_adaptor()));
577 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
578 this, SLOT(setSkip(int)));
579 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
580 this, SLOT(change_adaptor()));
581 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
582 this, SLOT(change_adaptor()));
584 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
585 this, SLOT(enableIndent(bool)));
586 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
587 this, SLOT(enableSkip(bool)));
589 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
590 this, SLOT(change_adaptor()));
591 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
592 this, SLOT(setColSep()));
594 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
595 textLayoutModule->lspacingLE));
596 textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
597 textLayoutModule->indentLE));
598 textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
599 textLayoutModule->skipLE));
601 textLayoutModule->indentCO->addItem(qt_("Default"));
602 textLayoutModule->indentCO->addItem(qt_("Custom"));
603 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
604 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
605 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
606 textLayoutModule->skipCO->addItem(qt_("Custom"));
607 textLayoutModule->lspacingCO->insertItem(
608 Spacing::Single, qt_("Single"));
609 textLayoutModule->lspacingCO->insertItem(
610 Spacing::Onehalf, qt_("OneHalf"));
611 textLayoutModule->lspacingCO->insertItem(
612 Spacing::Double, qt_("Double"));
613 textLayoutModule->lspacingCO->insertItem(
614 Spacing::Other, qt_("Custom"));
615 // initialize the length validator
616 bc().addCheckedLineEdit(textLayoutModule->indentLE);
617 bc().addCheckedLineEdit(textLayoutModule->skipLE);
620 outputModule = new UiWidget<Ui::OutputUi>;
622 connect(outputModule->xetexCB, SIGNAL(clicked()),
623 this, SLOT(change_adaptor()));
624 connect(outputModule->xetexCB, SIGNAL(toggled(bool)),
625 this, SLOT(xetexChanged(bool)));
626 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
627 this, SLOT(change_adaptor()));
630 fontModule = new UiWidget<Ui::FontUi>;
631 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
632 this, SLOT(change_adaptor()));
633 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
634 this, SLOT(romanChanged(int)));
635 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
636 this, SLOT(change_adaptor()));
637 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
638 this, SLOT(sansChanged(int)));
639 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
640 this, SLOT(change_adaptor()));
641 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
642 this, SLOT(ttChanged(int)));
643 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
644 this, SLOT(change_adaptor()));
645 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
646 this, SLOT(change_adaptor()));
647 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
648 this, SLOT(change_adaptor()));
649 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
650 this, SLOT(change_adaptor()));
651 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
652 this, SLOT(change_adaptor()));
653 connect(fontModule->fontScCB, SIGNAL(clicked()),
654 this, SLOT(change_adaptor()));
655 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
656 this, SLOT(change_adaptor()));
660 fontModule->fontsizeCO->addItem(qt_("Default"));
661 fontModule->fontsizeCO->addItem(qt_("10"));
662 fontModule->fontsizeCO->addItem(qt_("11"));
663 fontModule->fontsizeCO->addItem(qt_("12"));
665 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
666 fontModule->fontsDefaultCO->addItem(
667 qt_(GuiDocument::fontfamilies_gui[n]));
670 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
672 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
673 this, SLOT(papersizeChanged(int)));
674 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
675 this, SLOT(papersizeChanged(int)));
676 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
677 this, SLOT(portraitChanged()));
678 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
679 this, SLOT(change_adaptor()));
680 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
681 this, SLOT(change_adaptor()));
682 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
683 this, SLOT(change_adaptor()));
684 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
685 this, SLOT(change_adaptor()));
686 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
687 this, SLOT(change_adaptor()));
688 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
689 this, SLOT(change_adaptor()));
690 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
691 this, SLOT(change_adaptor()));
692 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
693 this, SLOT(change_adaptor()));
694 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
695 this, SLOT(change_adaptor()));
696 connect(pageLayoutModule->backgroundPB, SIGNAL(clicked()),
697 this, SLOT(changeBackgroundColor()));
698 connect(pageLayoutModule->delbackgroundTB, SIGNAL(clicked()),
699 this, SLOT(deleteBackgroundColor()));
701 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
702 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
703 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
704 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
705 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
706 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
707 pageLayoutModule->paperheightL);
708 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
709 pageLayoutModule->paperwidthL);
712 QComboBox * cb = pageLayoutModule->papersizeCO;
713 cb->addItem(qt_("Default"));
714 cb->addItem(qt_("Custom"));
715 cb->addItem(qt_("US letter"));
716 cb->addItem(qt_("US legal"));
717 cb->addItem(qt_("US executive"));
718 cb->addItem(qt_("A3"));
719 cb->addItem(qt_("A4"));
720 cb->addItem(qt_("A5"));
721 cb->addItem(qt_("B3"));
722 cb->addItem(qt_("B4"));
723 cb->addItem(qt_("B5"));
724 // remove the %-items from the unit choice
725 pageLayoutModule->paperwidthUnitCO->noPercents();
726 pageLayoutModule->paperheightUnitCO->noPercents();
727 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
728 pageLayoutModule->paperheightLE));
729 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
730 pageLayoutModule->paperwidthLE));
733 marginsModule = new UiWidget<Ui::MarginsUi>;
735 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
736 this, SLOT(setCustomMargins(bool)));
737 connect(marginsModule->marginCB, SIGNAL(clicked()),
738 this, SLOT(change_adaptor()));
739 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
740 this, SLOT(change_adaptor()));
741 connect(marginsModule->topUnit, SIGNAL(activated(int)),
742 this, SLOT(change_adaptor()));
743 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
744 this, SLOT(change_adaptor()));
745 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
746 this, SLOT(change_adaptor()));
747 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
748 this, SLOT(change_adaptor()));
749 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
750 this, SLOT(change_adaptor()));
751 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
752 this, SLOT(change_adaptor()));
753 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
754 this, SLOT(change_adaptor()));
755 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
756 this, SLOT(change_adaptor()));
757 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
758 this, SLOT(change_adaptor()));
759 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
760 this, SLOT(change_adaptor()));
761 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
762 this, SLOT(change_adaptor()));
763 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
764 this, SLOT(change_adaptor()));
765 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
766 this, SLOT(change_adaptor()));
767 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
768 this, SLOT(change_adaptor()));
769 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
770 this, SLOT(change_adaptor()));
771 marginsModule->topLE->setValidator(unsignedLengthValidator(
772 marginsModule->topLE));
773 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
774 marginsModule->bottomLE));
775 marginsModule->innerLE->setValidator(unsignedLengthValidator(
776 marginsModule->innerLE));
777 marginsModule->outerLE->setValidator(unsignedLengthValidator(
778 marginsModule->outerLE));
779 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
780 marginsModule->headsepLE));
781 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
782 marginsModule->headheightLE));
783 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
784 marginsModule->footskipLE));
785 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
786 marginsModule->columnsepLE));
788 bc().addCheckedLineEdit(marginsModule->topLE,
789 marginsModule->topL);
790 bc().addCheckedLineEdit(marginsModule->bottomLE,
791 marginsModule->bottomL);
792 bc().addCheckedLineEdit(marginsModule->innerLE,
793 marginsModule->innerL);
794 bc().addCheckedLineEdit(marginsModule->outerLE,
795 marginsModule->outerL);
796 bc().addCheckedLineEdit(marginsModule->headsepLE,
797 marginsModule->headsepL);
798 bc().addCheckedLineEdit(marginsModule->headheightLE,
799 marginsModule->headheightL);
800 bc().addCheckedLineEdit(marginsModule->footskipLE,
801 marginsModule->footskipL);
802 bc().addCheckedLineEdit(marginsModule->columnsepLE,
803 marginsModule->columnsepL);
806 langModule = new UiWidget<Ui::LanguageUi>;
808 connect(langModule->languageCO, SIGNAL(activated(int)),
809 this, SLOT(change_adaptor()));
810 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
811 this, SLOT(change_adaptor()));
812 connect(langModule->otherencodingRB, SIGNAL(clicked()),
813 this, SLOT(change_adaptor()));
814 connect(langModule->encodingCO, SIGNAL(activated(int)),
815 this, SLOT(change_adaptor()));
816 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
817 this, SLOT(change_adaptor()));
819 QAbstractItemModel * language_model = guiApp->languageModel();
820 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
821 language_model->sort(0);
822 langModule->languageCO->setModel(language_model);
824 // Always put the default encoding in the first position.
825 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
826 QStringList encodinglist;
827 Encodings::const_iterator it = encodings.begin();
828 Encodings::const_iterator const end = encodings.end();
829 for (; it != end; ++it)
830 encodinglist.append(qt_(it->guiName()));
832 langModule->encodingCO->addItems(encodinglist);
834 langModule->quoteStyleCO->addItem(qt_("``text''"));
835 langModule->quoteStyleCO->addItem(qt_("''text''"));
836 langModule->quoteStyleCO->addItem(qt_(",,text``"));
837 langModule->quoteStyleCO->addItem(qt_(",,text''"));
838 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
839 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
842 numberingModule = new UiWidget<Ui::NumberingUi>;
844 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
845 this, SLOT(change_adaptor()));
846 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
847 this, SLOT(change_adaptor()));
848 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
849 this, SLOT(updateNumbering()));
850 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
851 this, SLOT(updateNumbering()));
852 numberingModule->tocTW->setColumnCount(3);
853 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
854 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
855 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
858 biblioModule = new UiWidget<Ui::BiblioUi>;
859 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
860 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
861 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
862 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
864 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
865 this, SLOT(change_adaptor()));
866 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
867 this, SLOT(change_adaptor()));
868 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
869 this, SLOT(change_adaptor()));
870 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
871 this, SLOT(change_adaptor()));
872 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
873 this, SLOT(change_adaptor()));
874 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
875 this, SLOT(bibtexChanged(int)));
876 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
877 this, SLOT(change_adaptor()));
879 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
880 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
881 biblioModule->citeStyleCO->setCurrentIndex(0);
883 biblioModule->bibtexCO->clear();
885 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
886 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
887 it != lyxrc.bibtex_alternatives.end(); ++it) {
888 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
889 biblioModule->bibtexCO->addItem(command, command);
893 indicesModule = new GuiIndices;
894 connect(indicesModule, SIGNAL(changed()),
895 this, SLOT(change_adaptor()));
898 mathsModule = new UiWidget<Ui::MathsUi>;
899 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
900 mathsModule->amsCB, SLOT(setDisabled(bool)));
901 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
902 mathsModule->esintCB, SLOT(setDisabled(bool)));
904 connect(mathsModule->amsCB, SIGNAL(clicked()),
905 this, SLOT(change_adaptor()));
906 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
907 this, SLOT(change_adaptor()));
908 connect(mathsModule->esintCB, SIGNAL(clicked()),
909 this, SLOT(change_adaptor()));
910 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
911 this, SLOT(change_adaptor()));
913 latexModule = new UiWidget<Ui::LaTeXUi>;
915 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
916 this, SLOT(change_adaptor()));
917 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
918 this, SLOT(change_adaptor()));
919 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
920 this, SLOT(change_adaptor()));
921 connect(latexModule->classCO, SIGNAL(activated(int)),
922 this, SLOT(classChanged()));
923 connect(latexModule->classCO, SIGNAL(activated(int)),
924 this, SLOT(change_adaptor()));
925 connect(latexModule->layoutPB, SIGNAL(clicked()),
926 this, SLOT(browseLayout()));
927 connect(latexModule->layoutPB, SIGNAL(clicked()),
928 this, SLOT(change_adaptor()));
929 connect(latexModule->childDocGB, SIGNAL(clicked()),
930 this, SLOT(change_adaptor()));
931 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
932 this, SLOT(change_adaptor()));
933 connect(latexModule->childDocPB, SIGNAL(clicked()),
934 this, SLOT(browseMaster()));
935 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
936 this, SLOT(change_adaptor()));
938 // postscript drivers
939 for (int n = 0; tex_graphics[n][0]; ++n) {
940 QString enc = qt_(tex_graphics_gui[n]);
941 latexModule->psdriverCO->addItem(enc);
944 latexModule->classCO->setModel(&classes_model_);
945 LayoutFileList const & bcl = LayoutFileList::get();
946 vector<LayoutFileIndex> classList = bcl.classList();
947 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
949 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
950 vector<LayoutFileIndex>::const_iterator cen = classList.end();
951 for (int i = 0; cit != cen; ++cit, ++i) {
952 LayoutFile const & tc = bcl[*cit];
953 docstring item = (tc.isTeXClassAvailable()) ?
954 from_utf8(tc.description()) :
955 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
956 classes_model_.insertRow(i, toqstr(item), *cit);
960 branchesModule = new GuiBranches;
961 connect(branchesModule, SIGNAL(changed()),
962 this, SLOT(change_adaptor()));
963 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
964 this, SLOT(branchesRename(docstring const &, docstring const &)));
965 updateUnknownBranches();
968 preambleModule = new PreambleModule;
969 connect(preambleModule, SIGNAL(changed()),
970 this, SLOT(change_adaptor()));
973 bulletsModule = new BulletsModule;
974 connect(bulletsModule, SIGNAL(changed()),
975 this, SLOT(change_adaptor()));
978 modulesModule = new UiWidget<Ui::ModulesUi>;
981 new ModuleSelectionManager(modulesModule->availableLV,
982 modulesModule->selectedLV,
983 modulesModule->addPB, modulesModule->deletePB,
984 modulesModule->upPB, modulesModule->downPB,
985 availableModel(), selectedModel(), this);
986 connect(selectionManager, SIGNAL(updateHook()),
987 this, SLOT(updateModuleInfo()));
988 connect(selectionManager, SIGNAL(updateHook()),
989 this, SLOT(change_adaptor()));
990 connect(selectionManager, SIGNAL(selectionChanged()),
991 this, SLOT(modulesChanged()));
994 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
996 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
997 this, SLOT(change_adaptor()));
998 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
999 this, SLOT(change_adaptor()));
1000 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1001 this, SLOT(change_adaptor()));
1002 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1003 this, SLOT(change_adaptor()));
1004 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1005 this, SLOT(change_adaptor()));
1006 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1007 this, SLOT(change_adaptor()));
1008 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1009 this, SLOT(change_adaptor()));
1010 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1011 this, SLOT(change_adaptor()));
1012 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1013 this, SLOT(change_adaptor()));
1014 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1015 this, SLOT(change_adaptor()));
1016 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1017 this, SLOT(change_adaptor()));
1018 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1019 this, SLOT(change_adaptor()));
1020 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1021 this, SLOT(change_adaptor()));
1022 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1023 this, SLOT(change_adaptor()));
1024 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1025 this, SLOT(change_adaptor()));
1026 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1027 this, SLOT(change_adaptor()));
1029 for (int i = 0; backref_opts[i][0]; ++i)
1030 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1033 floatModule = new FloatPlacement;
1034 connect(floatModule, SIGNAL(changed()),
1035 this, SLOT(change_adaptor()));
1038 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1039 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1040 this, SLOT(change_adaptor()));
1041 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1042 this, SLOT(change_adaptor()));
1043 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1044 this, SLOT(setListingsMessage()));
1045 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1046 this, SLOT(setListingsMessage()));
1047 listingsModule->listingsTB->setPlainText(
1048 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1050 docPS->addPanel(latexModule, qt_("Document Class"));
1051 docPS->addPanel(modulesModule, qt_("Modules"));
1052 docPS->addPanel(fontModule, qt_("Fonts"));
1053 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1054 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1055 docPS->addPanel(marginsModule, qt_("Page Margins"));
1056 docPS->addPanel(langModule, qt_("Language"));
1057 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1058 docPS->addPanel(biblioModule, qt_("Bibliography"));
1059 docPS->addPanel(indicesModule, qt_("Indexes"));
1060 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1061 docPS->addPanel(mathsModule, qt_("Math Options"));
1062 docPS->addPanel(floatModule, qt_("Float Placement"));
1063 docPS->addPanel(listingsModule, qt_("Listings"));
1064 docPS->addPanel(bulletsModule, qt_("Bullets"));
1065 docPS->addPanel(branchesModule, qt_("Branches"));
1066 docPS->addPanel(outputModule, qt_("Output"));
1067 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1068 docPS->setCurrentPanel(qt_("Document Class"));
1069 // FIXME: hack to work around resizing bug in Qt >= 4.2
1070 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1071 #if QT_VERSION >= 0x040200
1072 docPS->updateGeometry();
1077 void GuiDocument::showPreamble()
1079 docPS->setCurrentPanel(qt_("LaTeX Preamble"));
1083 void GuiDocument::saveDefaultClicked()
1089 void GuiDocument::useDefaultsClicked()
1095 void GuiDocument::change_adaptor()
1101 QString GuiDocument::validateListingsParameters()
1103 // use a cache here to avoid repeated validation
1104 // of the same parameters
1105 static string param_cache;
1106 static QString msg_cache;
1108 if (listingsModule->bypassCB->isChecked())
1111 string params = fromqstr(listingsModule->listingsED->toPlainText());
1112 if (params != param_cache) {
1113 param_cache = params;
1114 msg_cache = toqstr(InsetListingsParams(params).validate());
1120 void GuiDocument::setListingsMessage()
1122 static bool isOK = true;
1123 QString msg = validateListingsParameters();
1124 if (msg.isEmpty()) {
1128 // listingsTB->setTextColor("black");
1129 listingsModule->listingsTB->setPlainText(
1130 qt_("Input listings parameters below. "
1131 "Enter ? for a list of parameters."));
1134 // listingsTB->setTextColor("red");
1135 listingsModule->listingsTB->setPlainText(msg);
1140 void GuiDocument::setLSpacing(int item)
1142 textLayoutModule->lspacingLE->setEnabled(item == 3);
1146 void GuiDocument::setIndent(int item)
1148 bool const enable = (item == 1);
1149 textLayoutModule->indentLE->setEnabled(enable);
1150 textLayoutModule->indentLengthCO->setEnabled(enable);
1151 textLayoutModule->skipLE->setEnabled(false);
1152 textLayoutModule->skipLengthCO->setEnabled(false);
1157 void GuiDocument::enableIndent(bool indent)
1159 textLayoutModule->skipLE->setEnabled(!indent);
1160 textLayoutModule->skipLengthCO->setEnabled(!indent);
1162 setIndent(textLayoutModule->indentCO->currentIndex());
1166 void GuiDocument::setSkip(int item)
1168 bool const enable = (item == 3);
1169 textLayoutModule->skipLE->setEnabled(enable);
1170 textLayoutModule->skipLengthCO->setEnabled(enable);
1175 void GuiDocument::enableSkip(bool skip)
1177 textLayoutModule->indentLE->setEnabled(!skip);
1178 textLayoutModule->indentLengthCO->setEnabled(!skip);
1180 setSkip(textLayoutModule->skipCO->currentIndex());
1184 void GuiDocument::portraitChanged()
1186 setMargins(pageLayoutModule->papersizeCO->currentIndex());
1190 void GuiDocument::setMargins(bool custom)
1192 bool const extern_geometry =
1193 documentClass().provides("geometry");
1194 marginsModule->marginCB->setEnabled(!extern_geometry);
1195 if (extern_geometry) {
1196 marginsModule->marginCB->setChecked(false);
1197 setCustomMargins(true);
1200 marginsModule->marginCB->setChecked(custom);
1201 setCustomMargins(custom);
1205 void GuiDocument::papersizeChanged(int paper_size)
1207 setCustomPapersize(paper_size == 1);
1211 void GuiDocument::setCustomPapersize(bool custom)
1213 pageLayoutModule->paperwidthL->setEnabled(custom);
1214 pageLayoutModule->paperwidthLE->setEnabled(custom);
1215 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1216 pageLayoutModule->paperheightL->setEnabled(custom);
1217 pageLayoutModule->paperheightLE->setEnabled(custom);
1218 pageLayoutModule->paperheightLE->setFocus();
1219 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1223 void GuiDocument::setColSep()
1225 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1229 void GuiDocument::setCustomMargins(bool custom)
1231 marginsModule->topL->setEnabled(!custom);
1232 marginsModule->topLE->setEnabled(!custom);
1233 marginsModule->topUnit->setEnabled(!custom);
1235 marginsModule->bottomL->setEnabled(!custom);
1236 marginsModule->bottomLE->setEnabled(!custom);
1237 marginsModule->bottomUnit->setEnabled(!custom);
1239 marginsModule->innerL->setEnabled(!custom);
1240 marginsModule->innerLE->setEnabled(!custom);
1241 marginsModule->innerUnit->setEnabled(!custom);
1243 marginsModule->outerL->setEnabled(!custom);
1244 marginsModule->outerLE->setEnabled(!custom);
1245 marginsModule->outerUnit->setEnabled(!custom);
1247 marginsModule->headheightL->setEnabled(!custom);
1248 marginsModule->headheightLE->setEnabled(!custom);
1249 marginsModule->headheightUnit->setEnabled(!custom);
1251 marginsModule->headsepL->setEnabled(!custom);
1252 marginsModule->headsepLE->setEnabled(!custom);
1253 marginsModule->headsepUnit->setEnabled(!custom);
1255 marginsModule->footskipL->setEnabled(!custom);
1256 marginsModule->footskipLE->setEnabled(!custom);
1257 marginsModule->footskipUnit->setEnabled(!custom);
1259 bool const enableColSep = !custom &&
1260 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1261 marginsModule->columnsepL->setEnabled(enableColSep);
1262 marginsModule->columnsepLE->setEnabled(enableColSep);
1263 marginsModule->columnsepUnit->setEnabled(enableColSep);
1266 void GuiDocument::changeBackgroundColor()
1268 QColor const & newColor = QColorDialog::getColor(
1269 rgb2qcolor(set_backgroundcolor), asQWidget());
1270 if (!newColor.isValid())
1272 // set the button color
1273 pageLayoutModule->backgroundPB->setStyleSheet(
1274 colorButtonStyleSheet(newColor));
1276 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1281 void GuiDocument::deleteBackgroundColor()
1283 // set the button color back to white
1284 pageLayoutModule->backgroundPB->setStyleSheet(
1285 colorButtonStyleSheet(QColor(Qt::white)));
1286 // save white as the set color
1287 set_backgroundcolor = rgbFromHexName("#ffffff");
1292 void GuiDocument::xetexChanged(bool xetex)
1295 updateDefaultFormat();
1296 langModule->encodingCO->setEnabled(!xetex &&
1297 !langModule->defaultencodingRB->isChecked());
1298 langModule->defaultencodingRB->setEnabled(!xetex);
1299 langModule->otherencodingRB->setEnabled(!xetex);
1301 fontModule->fontsDefaultCO->setEnabled(!xetex);
1302 fontModule->fontsDefaultLA->setEnabled(!xetex);
1303 fontModule->cjkFontLE->setEnabled(!xetex);
1304 fontModule->cjkFontLA->setEnabled(!xetex);
1307 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1308 bool scaleable = providesScale(font);
1309 fontModule->scaleSansSB->setEnabled(scaleable);
1310 fontModule->scaleSansLA->setEnabled(scaleable);
1312 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1313 scaleable = providesScale(font);
1314 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1315 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1317 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1318 fontModule->fontScCB->setEnabled(providesSC(font));
1319 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1323 void GuiDocument::updateFontsize(string const & items, string const & sel)
1325 fontModule->fontsizeCO->clear();
1326 fontModule->fontsizeCO->addItem(qt_("Default"));
1328 for (int n = 0; !token(items,'|',n).empty(); ++n)
1329 fontModule->fontsizeCO->
1330 addItem(toqstr(token(items,'|',n)));
1332 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1333 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1334 fontModule->fontsizeCO->setCurrentIndex(n);
1341 void GuiDocument::updateFontlist()
1343 fontModule->fontsRomanCO->clear();
1344 fontModule->fontsSansCO->clear();
1345 fontModule->fontsTypewriterCO->clear();
1347 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1348 if (outputModule->xetexCB->isChecked()) {
1349 fontModule->fontsRomanCO->addItem(qt_("Default"));
1350 fontModule->fontsSansCO->addItem(qt_("Default"));
1351 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1353 QFontDatabase fontdb;
1354 QStringList families(fontdb.families());
1355 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1356 fontModule->fontsRomanCO->addItem(*it);
1357 fontModule->fontsSansCO->addItem(*it);
1358 fontModule->fontsTypewriterCO->addItem(*it);
1363 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1364 QString font = qt_(tex_fonts_roman_gui[n]);
1365 if (!isFontAvailable(tex_fonts_roman[n]))
1366 font += qt_(" (not installed)");
1367 fontModule->fontsRomanCO->addItem(font);
1369 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1370 QString font = qt_(tex_fonts_sans_gui[n]);
1371 if (!isFontAvailable(tex_fonts_sans[n]))
1372 font += qt_(" (not installed)");
1373 fontModule->fontsSansCO->addItem(font);
1375 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1376 QString font = qt_(tex_fonts_monospaced_gui[n]);
1377 if (!isFontAvailable(tex_fonts_monospaced[n]))
1378 font += qt_(" (not installed)");
1379 fontModule->fontsTypewriterCO->addItem(font);
1384 void GuiDocument::romanChanged(int item)
1386 if (outputModule->xetexCB->isChecked())
1388 string const font = tex_fonts_roman[item];
1389 fontModule->fontScCB->setEnabled(providesSC(font));
1390 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1394 void GuiDocument::sansChanged(int item)
1396 if (outputModule->xetexCB->isChecked())
1398 string const font = tex_fonts_sans[item];
1399 bool scaleable = providesScale(font);
1400 fontModule->scaleSansSB->setEnabled(scaleable);
1401 fontModule->scaleSansLA->setEnabled(scaleable);
1405 void GuiDocument::ttChanged(int item)
1407 if (outputModule->xetexCB->isChecked())
1409 string const font = tex_fonts_monospaced[item];
1410 bool scaleable = providesScale(font);
1411 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1412 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1416 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1419 pageLayoutModule->pagestyleCO->clear();
1420 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1422 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1423 string style = token(items, '|', n);
1424 QString style_gui = qt_(style);
1425 pagestyles.push_back(pair<string, QString>(style, style_gui));
1426 pageLayoutModule->pagestyleCO->addItem(style_gui);
1429 if (sel == "default") {
1430 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1436 for (size_t i = 0; i < pagestyles.size(); ++i)
1437 if (pagestyles[i].first == sel)
1438 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1441 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1445 void GuiDocument::browseLayout()
1447 QString const label1 = qt_("Layouts|#o#O");
1448 QString const dir1 = toqstr(lyxrc.document_path);
1449 QStringList const filter(qt_("LyX Layout (*.layout)"));
1450 QString file = browseRelFile(QString(), bufferFilepath(),
1451 qt_("Local layout file"), filter, false,
1454 if (!file.endsWith(".layout"))
1457 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1458 fromqstr(bufferFilepath()));
1460 int const ret = Alert::prompt(_("Local layout file"),
1461 _("The layout file you have selected is a local layout\n"
1462 "file, not one in the system or user directory. Your\n"
1463 "document may not work with this layout if you do not\n"
1464 "keep the layout file in the document directory."),
1465 1, 1, _("&Set Layout"), _("&Cancel"));
1469 // load the layout file
1470 LayoutFileList & bcl = LayoutFileList::get();
1471 string classname = layoutFile.onlyFileName();
1472 // this will update an existing layout if that layout has been loaded before.
1473 LayoutFileIndex name = bcl.addLocalLayout(
1474 classname.substr(0, classname.size() - 7),
1475 layoutFile.onlyPath().absFilename());
1478 Alert::error(_("Error"),
1479 _("Unable to read local layout file."));
1483 // do not trigger classChanged if there is no change.
1484 if (latexModule->classCO->currentText() == toqstr(name))
1488 int idx = latexModule->classCO->findText(toqstr(name));
1490 classes_model_.insertRow(0, toqstr(name), name);
1491 latexModule->classCO->setCurrentIndex(0);
1493 latexModule->classCO->setCurrentIndex(idx);
1499 void GuiDocument::browseMaster()
1501 QString const title = qt_("Select master document");
1502 QString const dir1 = toqstr(lyxrc.document_path);
1503 QString const old = latexModule->childDocLE->text();
1504 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1505 QStringList const filter(qt_("LyX Files (*.lyx)"));
1506 QString file = browseRelFile(old, docpath, title, filter, false,
1507 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1509 latexModule->childDocLE->setText(file);
1513 void GuiDocument::classChanged()
1515 int idx = latexModule->classCO->currentIndex();
1518 string const classname = classes_model_.getIDString(idx);
1520 // check whether the selected modules have changed.
1521 bool modules_changed = false;
1522 unsigned int const srows = selectedModel()->rowCount();
1523 if (srows != bp_.getModules().size())
1524 modules_changed = true;
1526 list<string>::const_iterator mit = bp_.getModules().begin();
1527 list<string>::const_iterator men = bp_.getModules().end();
1528 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1529 if (selectedModel()->getIDString(i) != *mit) {
1530 modules_changed = true;
1535 if (modules_changed || lyxrc.auto_reset_options) {
1536 if (applyPB->isEnabled()) {
1537 int const ret = Alert::prompt(_("Unapplied changes"),
1538 _("Some changes in the dialog were not yet applied.\n"
1539 "If you do not apply now, they will be lost after this action."),
1540 1, 1, _("&Apply"), _("&Dismiss"));
1546 // We load the TextClass as soon as it is selected. This is
1547 // necessary so that other options in the dialog can be updated
1548 // according to the new class. Note, however, that, if you use
1549 // the scroll wheel when sitting on the combo box, we'll load a
1550 // lot of TextClass objects very quickly....
1551 if (!bp_.setBaseClass(classname)) {
1552 Alert::error(_("Error"), _("Unable to set document class."));
1555 if (lyxrc.auto_reset_options)
1556 bp_.useClassDefaults();
1558 // With the introduction of modules came a distinction between the base
1559 // class and the document class. The former corresponds to the main layout
1560 // file; the latter is that plus the modules (or the document-specific layout,
1561 // or whatever else there could be). Our parameters come from the document
1562 // class. So when we set the base class, we also need to recreate the document
1563 // class. Otherwise, we still have the old one.
1564 bp_.makeDocumentClass();
1569 void GuiDocument::bibtexChanged(int n)
1571 biblioModule->bibtexOptionsED->setEnabled(n != 0);
1577 // This is an insanely complicated attempt to make this sort of thing
1578 // work with RTL languages.
1579 docstring formatStrVec(vector<string> const & v, docstring const & s)
1581 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1585 return from_utf8(v[0]);
1586 if (v.size() == 2) {
1587 docstring retval = _("%1$s and %2$s");
1588 retval = subst(retval, _("and"), s);
1589 return bformat(retval, from_utf8(v[0]), from_utf8(v[1]));
1591 // The idea here is to format all but the last two items...
1592 int const vSize = v.size();
1593 docstring t2 = _("%1$s, %2$s");
1594 docstring retval = from_utf8(v[0]);
1595 for (int i = 1; i < vSize - 2; ++i)
1596 retval = bformat(t2, retval, from_utf8(v[i]));
1597 //...and then to plug them, and the last two, into this schema
1598 docstring t = _("%1$s, %2$s, and %3$s");
1599 t = subst(t, _("and"), s);
1600 return bformat(t, retval, from_utf8(v[vSize - 2]), from_utf8(v[vSize - 1]));
1603 vector<string> idsToNames(vector<string> const & idList)
1605 vector<string> retval;
1606 vector<string>::const_iterator it = idList.begin();
1607 vector<string>::const_iterator end = idList.end();
1608 for (; it != end; ++it) {
1609 LyXModule const * const mod = theModuleList[*it];
1611 retval.push_back(*it + " (Unavailable)");
1613 retval.push_back(mod->getName());
1620 void GuiDocument::modulesToParams(BufferParams & bp)
1622 // update list of loaded modules
1623 bp.clearLayoutModules();
1624 int const srows = modules_sel_model_.rowCount();
1625 for (int i = 0; i < srows; ++i)
1626 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1628 // update the list of removed modules
1629 bp.clearRemovedModules();
1630 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1631 list<string>::const_iterator rit = reqmods.begin();
1632 list<string>::const_iterator ren = reqmods.end();
1634 // check each of the default modules
1635 for (; rit != ren; rit++) {
1636 list<string>::const_iterator mit = bp.getModules().begin();
1637 list<string>::const_iterator men = bp.getModules().end();
1639 for (; mit != men; mit++) {
1646 // the module isn't present so must have been removed by the user
1647 bp.addRemovedModule(*rit);
1652 void GuiDocument::modulesChanged()
1654 modulesToParams(bp_);
1655 bp_.makeDocumentClass();
1660 void GuiDocument::updateModuleInfo()
1662 selectionManager->update();
1664 //Module description
1665 bool const focus_on_selected = selectionManager->selectedFocused();
1666 QAbstractItemView * lv;
1667 if (focus_on_selected)
1668 lv = modulesModule->selectedLV;
1670 lv= modulesModule->availableLV;
1671 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
1672 modulesModule->infoML->document()->clear();
1675 QModelIndex const & idx = lv->selectionModel()->currentIndex();
1676 GuiIdListModel const & id_model =
1677 focus_on_selected ? modules_sel_model_ : modules_av_model_;
1678 string const modName = id_model.getIDString(idx.row());
1679 docstring desc = getModuleDescription(modName);
1681 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
1682 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
1685 desc += _("Module provided by document class.");
1688 vector<string> pkglist = getPackageList(modName);
1689 docstring pkgdesc = formatStrVec(pkglist, _("and"));
1690 if (!pkgdesc.empty()) {
1693 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
1696 pkglist = getRequiredList(modName);
1697 if (!pkglist.empty()) {
1698 vector<string> const reqdescs = idsToNames(pkglist);
1699 pkgdesc = formatStrVec(reqdescs, _("or"));
1702 desc += bformat(_("Module required: %1$s."), pkgdesc);
1705 pkglist = getExcludedList(modName);
1706 if (!pkglist.empty()) {
1707 vector<string> const reqdescs = idsToNames(pkglist);
1708 pkgdesc = formatStrVec(reqdescs, _( "and"));
1711 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
1714 if (!isModuleAvailable(modName)) {
1717 desc += _("WARNING: Some required packages are unavailable!");
1720 modulesModule->infoML->document()->setPlainText(toqstr(desc));
1724 void GuiDocument::updateNumbering()
1726 DocumentClass const & tclass = documentClass();
1728 numberingModule->tocTW->setUpdatesEnabled(false);
1729 numberingModule->tocTW->clear();
1731 int const depth = numberingModule->depthSL->value();
1732 int const toc = numberingModule->tocSL->value();
1733 QString const no = qt_("No");
1734 QString const yes = qt_("Yes");
1735 QTreeWidgetItem * item = 0;
1737 DocumentClass::const_iterator lit = tclass.begin();
1738 DocumentClass::const_iterator len = tclass.end();
1739 for (; lit != len; ++lit) {
1740 int const toclevel = lit->toclevel;
1741 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
1742 item = new QTreeWidgetItem(numberingModule->tocTW);
1743 item->setText(0, toqstr(translateIfPossible(lit->name())));
1744 item->setText(1, (toclevel <= depth) ? yes : no);
1745 item->setText(2, (toclevel <= toc) ? yes : no);
1749 numberingModule->tocTW->setUpdatesEnabled(true);
1750 numberingModule->tocTW->update();
1754 void GuiDocument::updateDefaultFormat()
1756 // make a copy in order to consider unapplied changes
1757 Buffer * tmpbuf = const_cast<Buffer *>(&buffer());
1758 tmpbuf->params().useXetex = outputModule->xetexCB->isChecked();
1759 int idx = latexModule->classCO->currentIndex();
1761 string const classname = classes_model_.getIDString(idx);
1762 tmpbuf->params().setBaseClass(classname);
1763 tmpbuf->params().makeDocumentClass();
1765 outputModule->defaultFormatCO->blockSignals(true);
1766 outputModule->defaultFormatCO->clear();
1767 outputModule->defaultFormatCO->addItem(qt_("Default"),
1768 QVariant(QString("default")));
1769 typedef vector<Format const *> Formats;
1770 Formats formats = tmpbuf->exportableFormats(true);
1771 Formats::const_iterator cit = formats.begin();
1772 Formats::const_iterator end = formats.end();
1773 for (; cit != end; ++cit)
1774 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
1775 QVariant(toqstr((*cit)->name())));
1776 outputModule->defaultFormatCO->blockSignals(false);
1780 void GuiDocument::applyView()
1783 preambleModule->apply(bp_);
1786 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
1789 bp_.setCiteEngine(ENGINE_BASIC);
1791 if (biblioModule->citeNatbibRB->isChecked()) {
1792 bool const use_numerical_citations =
1793 biblioModule->citeStyleCO->currentIndex();
1794 if (use_numerical_citations)
1795 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
1797 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
1799 } else if (biblioModule->citeJurabibRB->isChecked())
1800 bp_.setCiteEngine(ENGINE_JURABIB);
1803 biblioModule->bibtopicCB->isChecked();
1805 string const bibtex_command =
1806 fromqstr(biblioModule->bibtexCO->itemData(
1807 biblioModule->bibtexCO->currentIndex()).toString());
1808 string const bibtex_options =
1809 fromqstr(biblioModule->bibtexOptionsED->text());
1810 if (bibtex_command == "default" || bibtex_options.empty())
1811 bp_.bibtex_command = bibtex_command;
1813 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
1816 indicesModule->apply(bp_);
1818 // language & quotes
1819 if (langModule->defaultencodingRB->isChecked()) {
1820 bp_.inputenc = "auto";
1822 int i = langModule->encodingCO->currentIndex();
1824 bp_.inputenc = "default";
1826 QString const enc_gui =
1827 langModule->encodingCO->currentText();
1828 Encodings::const_iterator it = encodings.begin();
1829 Encodings::const_iterator const end = encodings.end();
1831 for (; it != end; ++it) {
1832 if (qt_(it->guiName()) == enc_gui) {
1833 bp_.inputenc = it->latexName();
1839 // should not happen
1840 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
1841 bp_.inputenc = "default";
1846 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
1847 switch (langModule->quoteStyleCO->currentIndex()) {
1849 lga = InsetQuotes::EnglishQuotes;
1852 lga = InsetQuotes::SwedishQuotes;
1855 lga = InsetQuotes::GermanQuotes;
1858 lga = InsetQuotes::PolishQuotes;
1861 lga = InsetQuotes::FrenchQuotes;
1864 lga = InsetQuotes::DanishQuotes;
1867 bp_.quotes_language = lga;
1869 QString const lang = langModule->languageCO->itemData(
1870 langModule->languageCO->currentIndex()).toString();
1871 bp_.language = languages.getLanguage(fromqstr(lang));
1874 if (bp_.documentClass().hasTocLevels()) {
1875 bp_.tocdepth = numberingModule->tocSL->value();
1876 bp_.secnumdepth = numberingModule->depthSL->value();
1880 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
1881 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
1882 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
1883 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
1886 bp_.graphicsDriver =
1887 tex_graphics[latexModule->psdriverCO->currentIndex()];
1890 int idx = latexModule->classCO->currentIndex();
1892 string const classname = classes_model_.getIDString(idx);
1893 bp_.setBaseClass(classname);
1897 modulesToParams(bp_);
1900 if (mathsModule->amsautoCB->isChecked()) {
1901 bp_.use_amsmath = BufferParams::package_auto;
1903 if (mathsModule->amsCB->isChecked())
1904 bp_.use_amsmath = BufferParams::package_on;
1906 bp_.use_amsmath = BufferParams::package_off;
1909 if (mathsModule->esintautoCB->isChecked())
1910 bp_.use_esint = BufferParams::package_auto;
1912 if (mathsModule->esintCB->isChecked())
1913 bp_.use_esint = BufferParams::package_on;
1915 bp_.use_esint = BufferParams::package_off;
1919 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1920 bp_.pagestyle = "default";
1922 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
1923 for (size_t i = 0; i != pagestyles.size(); ++i)
1924 if (pagestyles[i].second == style_gui)
1925 bp_.pagestyle = pagestyles[i].first;
1929 switch (textLayoutModule->lspacingCO->currentIndex()) {
1931 bp_.spacing().set(Spacing::Single);
1934 bp_.spacing().set(Spacing::Onehalf);
1937 bp_.spacing().set(Spacing::Double);
1940 bp_.spacing().set(Spacing::Other,
1941 widgetToDoubleStr(textLayoutModule->lspacingLE));
1945 if (textLayoutModule->twoColumnCB->isChecked())
1950 if (textLayoutModule->indentRB->isChecked()) {
1951 // if paragraphs are separated by an indentation
1952 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
1953 switch (textLayoutModule->indentCO->currentIndex()) {
1955 bp_.setIndentation(HSpace(HSpace::DEFAULT));
1958 HSpace indent = HSpace(
1959 widgetsToLength(textLayoutModule->indentLE,
1960 textLayoutModule->indentLengthCO)
1962 bp_.setIndentation(indent);
1966 // this should never happen
1967 bp_.setIndentation(HSpace(HSpace::DEFAULT));
1971 // if paragraphs are separated by a skip
1972 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
1973 switch (textLayoutModule->skipCO->currentIndex()) {
1975 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
1978 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1981 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
1986 widgetsToLength(textLayoutModule->skipLE,
1987 textLayoutModule->skipLengthCO)
1993 // this should never happen
1994 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2000 fromqstr(latexModule->optionsLE->text());
2002 bp_.use_default_options =
2003 latexModule->defaultOptionsCB->isChecked();
2005 if (latexModule->childDocGB->isChecked())
2007 fromqstr(latexModule->childDocLE->text());
2009 bp_.master = string();
2012 bp_.float_placement = floatModule->get();
2015 // text should have passed validation
2016 bp_.listings_params =
2017 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2020 bp_.defaultOutputFormat = fromqstr(outputModule->defaultFormatCO->itemData(
2021 outputModule->defaultFormatCO->currentIndex()).toString());
2023 bool const xetex = outputModule->xetexCB->isChecked();
2024 bp_.useXetex = xetex;
2028 if (fontModule->fontsRomanCO->currentIndex() == 0)
2029 bp_.fontsRoman = "default";
2032 fromqstr(fontModule->fontsRomanCO->currentText());
2034 if (fontModule->fontsSansCO->currentIndex() == 0)
2035 bp_.fontsSans = "default";
2038 fromqstr(fontModule->fontsSansCO->currentText());
2040 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
2041 bp_.fontsTypewriter = "default";
2043 bp_.fontsTypewriter =
2044 fromqstr(fontModule->fontsTypewriterCO->currentText());
2047 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
2050 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
2052 bp_.fontsTypewriter =
2053 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
2057 fromqstr(fontModule->cjkFontLE->text());
2059 bp_.fontsSansScale = fontModule->scaleSansSB->value();
2061 bp_.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
2063 bp_.fontsSC = fontModule->fontScCB->isChecked();
2065 bp_.fontsOSF = fontModule->fontOsfCB->isChecked();
2068 bp_.fontsDefaultFamily = "default";
2070 bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
2071 fontModule->fontsDefaultCO->currentIndex()];
2073 if (fontModule->fontsizeCO->currentIndex() == 0)
2074 bp_.fontsize = "default";
2077 fromqstr(fontModule->fontsizeCO->currentText());
2080 bp_.papersize = PAPER_SIZE(
2081 pageLayoutModule->papersizeCO->currentIndex());
2083 // custom, A3, B3 and B4 paper sizes need geometry
2084 int psize = pageLayoutModule->papersizeCO->currentIndex();
2085 bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
2087 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2088 pageLayoutModule->paperwidthUnitCO);
2090 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2091 pageLayoutModule->paperheightUnitCO);
2093 if (pageLayoutModule->facingPagesCB->isChecked())
2094 bp_.sides = TwoSides;
2096 bp_.sides = OneSide;
2098 if (pageLayoutModule->landscapeRB->isChecked())
2099 bp_.orientation = ORIENTATION_LANDSCAPE;
2101 bp_.orientation = ORIENTATION_PORTRAIT;
2103 bp_.backgroundcolor = set_backgroundcolor;
2106 bp_.use_geometry = !marginsModule->marginCB->isChecked()
2109 Ui::MarginsUi const * m = marginsModule;
2111 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2112 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2113 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2114 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2115 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2116 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2117 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2118 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2121 branchesModule->apply(bp_);
2124 PDFOptions & pdf = bp_.pdfoptions();
2125 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2126 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2127 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2128 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2129 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2131 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2132 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2133 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2134 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2136 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2137 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2138 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2139 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2141 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2142 if (pdfSupportModule->fullscreenCB->isChecked())
2143 pdf.pagemode = pdf.pagemode_fullscreen;
2145 pdf.pagemode.clear();
2146 pdf.quoted_options = pdf.quoted_options_check(
2147 fromqstr(pdfSupportModule->optionsLE->text()));
2151 void GuiDocument::paramsToDialog()
2153 // set the default unit
2154 Length::UNIT const defaultUnit = Length::defaultUnit();
2157 preambleModule->update(bp_, id());
2160 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2163 biblioModule->citeDefaultRB->setChecked(
2164 bp_.citeEngine() == ENGINE_BASIC);
2166 biblioModule->citeNatbibRB->setChecked(
2167 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2168 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2170 biblioModule->citeStyleCO->setCurrentIndex(
2171 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2173 biblioModule->citeJurabibRB->setChecked(
2174 bp_.citeEngine() == ENGINE_JURABIB);
2176 biblioModule->bibtopicCB->setChecked(
2181 split(bp_.bibtex_command, command, ' ');
2183 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2185 biblioModule->bibtexCO->setCurrentIndex(bpos);
2186 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2188 biblioModule->bibtexCO->setCurrentIndex(0);
2189 biblioModule->bibtexOptionsED->clear();
2191 biblioModule->bibtexOptionsED->setEnabled(
2192 biblioModule->bibtexCO->currentIndex() != 0);
2195 indicesModule->update(bp_);
2197 // language & quotes
2198 int const pos = langModule->languageCO->findData(toqstr(
2199 bp_.language->lang()));
2200 langModule->languageCO->setCurrentIndex(pos);
2202 langModule->quoteStyleCO->setCurrentIndex(
2203 bp_.quotes_language);
2205 bool default_enc = true;
2206 if (bp_.inputenc != "auto") {
2207 default_enc = false;
2208 if (bp_.inputenc == "default") {
2209 langModule->encodingCO->setCurrentIndex(0);
2212 Encodings::const_iterator it = encodings.begin();
2213 Encodings::const_iterator const end = encodings.end();
2214 for (; it != end; ++it) {
2215 if (it->latexName() == bp_.inputenc) {
2216 enc_gui = it->guiName();
2220 int const i = langModule->encodingCO->findText(
2223 langModule->encodingCO->setCurrentIndex(i);
2225 // unknown encoding. Set to default.
2229 langModule->defaultencodingRB->setChecked(default_enc);
2230 langModule->otherencodingRB->setChecked(!default_enc);
2233 int const min_toclevel = documentClass().min_toclevel();
2234 int const max_toclevel = documentClass().max_toclevel();
2235 if (documentClass().hasTocLevels()) {
2236 numberingModule->setEnabled(true);
2237 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2238 numberingModule->depthSL->setMaximum(max_toclevel);
2239 numberingModule->depthSL->setValue(bp_.secnumdepth);
2240 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2241 numberingModule->tocSL->setMaximum(max_toclevel);
2242 numberingModule->tocSL->setValue(bp_.tocdepth);
2245 numberingModule->setEnabled(false);
2246 numberingModule->tocTW->clear();
2250 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2251 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2252 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2253 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2254 bulletsModule->init();
2257 int nitem = findToken(tex_graphics, bp_.graphicsDriver);
2259 latexModule->psdriverCO->setCurrentIndex(nitem);
2262 mathsModule->amsCB->setChecked(
2263 bp_.use_amsmath == BufferParams::package_on);
2264 mathsModule->amsautoCB->setChecked(
2265 bp_.use_amsmath == BufferParams::package_auto);
2267 mathsModule->esintCB->setChecked(
2268 bp_.use_esint == BufferParams::package_on);
2269 mathsModule->esintautoCB->setChecked(
2270 bp_.use_esint == BufferParams::package_auto);
2272 switch (bp_.spacing().getSpace()) {
2273 case Spacing::Other: nitem = 3; break;
2274 case Spacing::Double: nitem = 2; break;
2275 case Spacing::Onehalf: nitem = 1; break;
2276 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2280 string const & layoutID = bp_.baseClassID();
2281 setLayoutComboByIDString(layoutID);
2283 updatePagestyle(documentClass().opt_pagestyle(),
2286 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2287 if (bp_.spacing().getSpace() == Spacing::Other) {
2288 doubleToWidget(textLayoutModule->lspacingLE,
2289 bp_.spacing().getValueAsString());
2293 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2294 textLayoutModule->indentRB->setChecked(true);
2295 string indentation = bp_.getIndentation().asLyXCommand();
2297 if (indentation != "default") {
2298 lengthToWidgets(textLayoutModule->indentLE,
2299 textLayoutModule->indentLengthCO,
2300 indentation, defaultUnit);
2303 textLayoutModule->indentCO->setCurrentIndex(indent);
2306 textLayoutModule->skipRB->setChecked(true);
2308 switch (bp_.getDefSkip().kind()) {
2309 case VSpace::SMALLSKIP:
2312 case VSpace::MEDSKIP:
2315 case VSpace::BIGSKIP:
2318 case VSpace::LENGTH:
2321 string const length = bp_.getDefSkip().asLyXCommand();
2322 lengthToWidgets(textLayoutModule->skipLE,
2323 textLayoutModule->skipLengthCO,
2324 length, defaultUnit);
2331 textLayoutModule->skipCO->setCurrentIndex(skip);
2335 textLayoutModule->twoColumnCB->setChecked(
2338 if (!bp_.options.empty()) {
2339 latexModule->optionsLE->setText(
2340 toqstr(bp_.options));
2342 latexModule->optionsLE->setText(QString());
2346 latexModule->defaultOptionsCB->setChecked(
2347 bp_.use_default_options);
2348 updateSelectedModules();
2349 selectionManager->updateProvidedModules(
2350 bp_.baseClass()->providedModules());
2351 selectionManager->updateExcludedModules(
2352 bp_.baseClass()->excludedModules());
2354 if (!documentClass().options().empty()) {
2355 latexModule->defaultOptionsLE->setText(
2356 toqstr(documentClass().options()));
2358 latexModule->defaultOptionsLE->setText(
2359 toqstr(_("[No options predefined]")));
2362 latexModule->defaultOptionsLE->setEnabled(
2363 bp_.use_default_options
2364 && !documentClass().options().empty());
2366 latexModule->defaultOptionsCB->setEnabled(
2367 !documentClass().options().empty());
2369 if (!bp_.master.empty()) {
2370 latexModule->childDocGB->setChecked(true);
2371 latexModule->childDocLE->setText(
2372 toqstr(bp_.master));
2374 latexModule->childDocLE->setText(QString());
2375 latexModule->childDocGB->setChecked(false);
2379 floatModule->set(bp_.float_placement);
2382 // break listings_params to multiple lines
2384 InsetListingsParams(bp_.listings_params).separatedParams();
2385 listingsModule->listingsED->setPlainText(toqstr(lstparams));
2388 // update combobox with formats
2389 updateDefaultFormat();
2390 int index = outputModule->defaultFormatCO->findData(toqstr(
2391 bp_.defaultOutputFormat));
2392 // set to default if format is not found
2395 outputModule->defaultFormatCO->setCurrentIndex(index);
2396 outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
2397 outputModule->xetexCB->setChecked(
2398 bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
2401 updateFontsize(documentClass().opt_fontsize(),
2405 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2406 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
2407 fontModule->fontsRomanCO->setCurrentIndex(i);
2412 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2413 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
2414 fontModule->fontsSansCO->setCurrentIndex(i);
2418 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2419 if (fontModule->fontsTypewriterCO->itemText(i) ==
2420 toqstr(bp_.fontsTypewriter)) {
2421 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2426 int n = findToken(tex_fonts_roman, bp_.fontsRoman);
2428 fontModule->fontsRomanCO->setCurrentIndex(n);
2432 n = findToken(tex_fonts_sans, bp_.fontsSans);
2434 fontModule->fontsSansCO->setCurrentIndex(n);
2438 n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
2440 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2445 if (!bp_.fontsCJK.empty())
2446 fontModule->cjkFontLE->setText(
2447 toqstr(bp_.fontsCJK));
2449 fontModule->cjkFontLE->setText(QString());
2451 fontModule->fontScCB->setChecked(bp_.fontsSC);
2452 fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
2453 fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
2454 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
2456 int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
2458 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2461 bool const extern_geometry =
2462 documentClass().provides("geometry");
2463 int const psize = bp_.papersize;
2464 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2465 setCustomPapersize(!extern_geometry && psize == 1);
2466 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2468 bool const landscape =
2469 bp_.orientation == ORIENTATION_LANDSCAPE;
2470 pageLayoutModule->landscapeRB->setChecked(landscape);
2471 pageLayoutModule->portraitRB->setChecked(!landscape);
2472 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2473 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2475 pageLayoutModule->facingPagesCB->setChecked(
2476 bp_.sides == TwoSides);
2478 pageLayoutModule->backgroundPB->setStyleSheet(
2479 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2480 set_backgroundcolor = bp_.backgroundcolor;
2482 lengthToWidgets(pageLayoutModule->paperwidthLE,
2483 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2484 lengthToWidgets(pageLayoutModule->paperheightLE,
2485 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2488 Ui::MarginsUi * m = marginsModule;
2490 setMargins(!bp_.use_geometry);
2492 lengthToWidgets(m->topLE, m->topUnit,
2493 bp_.topmargin, defaultUnit);
2495 lengthToWidgets(m->bottomLE, m->bottomUnit,
2496 bp_.bottommargin, defaultUnit);
2498 lengthToWidgets(m->innerLE, m->innerUnit,
2499 bp_.leftmargin, defaultUnit);
2501 lengthToWidgets(m->outerLE, m->outerUnit,
2502 bp_.rightmargin, defaultUnit);
2504 lengthToWidgets(m->headheightLE, m->headheightUnit,
2505 bp_.headheight, defaultUnit);
2507 lengthToWidgets(m->headsepLE, m->headsepUnit,
2508 bp_.headsep, defaultUnit);
2510 lengthToWidgets(m->footskipLE, m->footskipUnit,
2511 bp_.footskip, defaultUnit);
2513 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2514 bp_.columnsep, defaultUnit);
2517 updateUnknownBranches();
2518 branchesModule->update(bp_);
2521 PDFOptions const & pdf = bp_.pdfoptions();
2522 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2523 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2524 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2525 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2526 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2528 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2529 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2530 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2532 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2534 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2535 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2536 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2537 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2539 nn = findToken(backref_opts, pdf.backref);
2541 pdfSupportModule->backrefCO->setCurrentIndex(nn);
2543 pdfSupportModule->fullscreenCB->setChecked
2544 (pdf.pagemode == pdf.pagemode_fullscreen);
2546 pdfSupportModule->optionsLE->setText(
2547 toqstr(pdf.quoted_options));
2549 // Make sure that the bc is in the INITIAL state
2550 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
2553 // clear changed branches cache
2554 changedBranches_.clear();
2558 void GuiDocument::saveDocDefault()
2560 // we have to apply the params first
2566 void GuiDocument::updateAvailableModules()
2568 modules_av_model_.clear();
2569 list<modInfoStruct> const & modInfoList = getModuleInfo();
2570 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
2571 list<modInfoStruct>::const_iterator men = modInfoList.end();
2572 for (int i = 0; mit != men; ++mit, ++i)
2573 modules_av_model_.insertRow(i, mit->name, mit->id,
2578 void GuiDocument::updateSelectedModules()
2580 modules_sel_model_.clear();
2581 list<modInfoStruct> const selModList = getSelectedModules();
2582 list<modInfoStruct>::const_iterator mit = selModList.begin();
2583 list<modInfoStruct>::const_iterator men = selModList.end();
2584 for (int i = 0; mit != men; ++mit, ++i)
2585 modules_sel_model_.insertRow(i, mit->name, mit->id,
2590 void GuiDocument::updateContents()
2592 // Nothing to do here as the document settings is not cursor dependant.
2597 void GuiDocument::useClassDefaults()
2599 if (applyPB->isEnabled()) {
2600 int const ret = Alert::prompt(_("Unapplied changes"),
2601 _("Some changes in the dialog were not yet applied.\n"
2602 "If you do not apply now, they will be lost after this action."),
2603 1, 1, _("&Apply"), _("&Dismiss"));
2608 int idx = latexModule->classCO->currentIndex();
2609 string const classname = classes_model_.getIDString(idx);
2610 if (!bp_.setBaseClass(classname)) {
2611 Alert::error(_("Error"), _("Unable to set document class."));
2614 bp_.useClassDefaults();
2619 void GuiDocument::setLayoutComboByIDString(string const & idString)
2621 int idx = classes_model_.findIDString(idString);
2623 Alert::warning(_("Can't set layout!"),
2624 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2626 latexModule->classCO->setCurrentIndex(idx);
2630 bool GuiDocument::isValid()
2632 return validateListingsParameters().isEmpty()
2633 && (textLayoutModule->skipCO->currentIndex() != 3
2634 || !textLayoutModule->skipLE->text().isEmpty()
2635 || textLayoutModule->indentRB->isChecked())
2636 && (textLayoutModule->indentCO->currentIndex() != 1
2637 || !textLayoutModule->indentLE->text().isEmpty()
2638 || textLayoutModule->skipRB->isChecked());
2642 char const * const GuiDocument::fontfamilies[5] = {
2643 "default", "rmdefault", "sfdefault", "ttdefault", ""
2647 char const * GuiDocument::fontfamilies_gui[5] = {
2648 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2652 bool GuiDocument::initialiseParams(string const &)
2654 BufferView const * view = bufferview();
2656 bp_ = BufferParams();
2660 bp_ = view->buffer().params();
2662 updateAvailableModules();
2663 //FIXME It'd be nice to make sure here that the selected
2664 //modules are consistent: That required modules are actually
2665 //selected, and that we don't have conflicts. If so, we could
2666 //at least pop up a warning.
2672 void GuiDocument::clearParams()
2674 bp_ = BufferParams();
2678 BufferId GuiDocument::id() const
2680 BufferView const * const view = bufferview();
2681 return view? &view->buffer() : 0;
2685 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2687 return moduleNames_;
2691 list<GuiDocument::modInfoStruct> const
2692 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
2694 LayoutModuleList::const_iterator it = mods.begin();
2695 LayoutModuleList::const_iterator end = mods.end();
2696 list<modInfoStruct> mInfo;
2697 for (; it != end; ++it) {
2700 LyXModule const * const mod = theModuleList[*it];
2703 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
2705 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
2712 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2714 return makeModuleInfo(params().getModules());
2718 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
2720 return makeModuleInfo(params().baseClass()->providedModules());
2724 DocumentClass const & GuiDocument::documentClass() const
2726 return bp_.documentClass();
2730 static void dispatch_bufferparams(Dialog const & dialog,
2731 BufferParams const & bp, FuncCode lfun)
2734 ss << "\\begin_header\n";
2736 ss << "\\end_header\n";
2737 dialog.dispatch(FuncRequest(lfun, ss.str()));
2741 void GuiDocument::dispatchParams()
2743 // This must come first so that a language change is correctly noticed
2746 // Apply the BufferParams. Note that this will set the base class
2747 // and then update the buffer's layout.
2748 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2750 if (!params().master.empty()) {
2751 FileName const master_file = support::makeAbsPath(params().master,
2752 support::onlyPath(buffer().absFileName()));
2753 if (isLyXFilename(master_file.absFilename())) {
2754 Buffer * master = checkAndLoadLyXFile(master_file);
2756 if (master->isChild(const_cast<Buffer *>(&buffer())))
2757 const_cast<Buffer &>(buffer()).setParent(master);
2759 Alert::warning(_("Assigned master does not include this file"),
2760 bformat(_("You must include this file in the document\n"
2761 "'%1$s' in order to use the master document\n"
2762 "feature."), from_utf8(params().master)));
2764 Alert::warning(_("Could not load master"),
2765 bformat(_("The master document '%1$s'\n"
2766 "could not be loaded."),
2767 from_utf8(params().master)));
2771 // Generate the colours requested by each new branch.
2772 BranchList & branchlist = params().branchlist();
2773 if (!branchlist.empty()) {
2774 BranchList::const_iterator it = branchlist.begin();
2775 BranchList::const_iterator const end = branchlist.end();
2776 for (; it != end; ++it) {
2777 docstring const & current_branch = it->branch();
2778 Branch const * branch = branchlist.find(current_branch);
2779 string const x11hexname = X11hexname(branch->color());
2780 // display the new color
2781 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2782 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2785 // Open insets of selected branches, close deselected ones
2786 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2789 // rename branches in the document
2790 executeBranchRenaming();
2791 // and clear changed branches cache
2792 changedBranches_.clear();
2794 // Generate the colours requested by indices.
2795 IndicesList & indiceslist = params().indiceslist();
2796 if (!indiceslist.empty()) {
2797 IndicesList::const_iterator it = indiceslist.begin();
2798 IndicesList::const_iterator const end = indiceslist.end();
2799 for (; it != end; ++it) {
2800 docstring const & current_index = it->shortcut();
2801 Index const * index = indiceslist.findShortcut(current_index);
2802 string const x11hexname = X11hexname(index->color());
2803 // display the new color
2804 docstring const str = current_index + ' ' + from_ascii(x11hexname);
2805 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2808 // FIXME: If we used an LFUN, we would not need those two lines:
2809 BufferView * bv = const_cast<BufferView *>(bufferview());
2810 bv->processUpdateFlags(Update::Force | Update::FitCursor);
2814 void GuiDocument::setLanguage() const
2816 Language const * const newL = bp_.language;
2817 if (buffer().params().language == newL)
2820 string const & lang_name = newL->lang();
2821 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
2825 void GuiDocument::saveAsDefault() const
2827 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
2831 bool GuiDocument::isFontAvailable(string const & font) const
2833 if (font == "default" || font == "cmr"
2834 || font == "cmss" || font == "cmtt")
2835 // these are standard
2837 if (font == "lmodern" || font == "lmss" || font == "lmtt")
2838 return LaTeXFeatures::isAvailable("lmodern");
2839 if (font == "times" || font == "palatino"
2840 || font == "helvet" || font == "courier")
2841 return LaTeXFeatures::isAvailable("psnfss");
2842 if (font == "cmbr" || font == "cmtl")
2843 return LaTeXFeatures::isAvailable("cmbright");
2844 if (font == "utopia")
2845 return LaTeXFeatures::isAvailable("utopia")
2846 || LaTeXFeatures::isAvailable("fourier");
2847 if (font == "beraserif" || font == "berasans"
2848 || font == "beramono")
2849 return LaTeXFeatures::isAvailable("bera");
2850 return LaTeXFeatures::isAvailable(font);
2854 bool GuiDocument::providesOSF(string const & font) const
2856 if (outputModule->xetexCB->isChecked())
2857 // FIXME: we should check if the fonts really
2858 // have OSF support. But how?
2861 return isFontAvailable("eco");
2862 if (font == "palatino")
2863 return isFontAvailable("mathpazo");
2868 bool GuiDocument::providesSC(string const & font) const
2870 if (outputModule->xetexCB->isChecked())
2872 if (font == "palatino")
2873 return isFontAvailable("mathpazo");
2874 if (font == "utopia")
2875 return isFontAvailable("fourier");
2880 bool GuiDocument::providesScale(string const & font) const
2882 if (outputModule->xetexCB->isChecked())
2884 return font == "helvet" || font == "luximono"
2885 || font == "berasans" || font == "beramono";
2889 void GuiDocument::loadModuleInfo()
2891 moduleNames_.clear();
2892 LyXModuleList::const_iterator it = theModuleList.begin();
2893 LyXModuleList::const_iterator end = theModuleList.end();
2894 for (; it != end; ++it) {
2898 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
2899 // this is supposed to give us the first sentence of the description
2902 toqstr(translateIfPossible(from_utf8(it->getDescription())));
2903 int const pos = desc.indexOf(".");
2905 desc.truncate(pos + 1);
2906 m.description = desc;
2907 moduleNames_.push_back(m);
2912 void GuiDocument::updateUnknownBranches()
2914 list<docstring> used_branches;
2915 buffer().getUsedBranches(used_branches);
2916 list<docstring>::const_iterator it = used_branches.begin();
2917 QStringList unknown_branches;
2918 for (; it != used_branches.end() ; ++it) {
2919 if (!buffer().params().branchlist().find(*it))
2920 unknown_branches.append(toqstr(*it));
2922 branchesModule->setUnknownBranches(unknown_branches);
2926 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
2928 map<docstring, docstring>::iterator it = changedBranches_.begin();
2929 for (; it != changedBranches_.end() ; ++it) {
2930 if (it->second == oldname) {
2931 // branch has already been renamed
2932 it->second = newname;
2937 changedBranches_[oldname] = newname;
2941 void GuiDocument::executeBranchRenaming() const
2943 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
2944 for (; it != changedBranches_.end() ; ++it) {
2945 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
2946 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
2951 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
2954 } // namespace frontend
2957 #include "moc_GuiDocument.cpp"