#include "GuiDocument.h"
-#include "FloatPlacement.h"
-#include "LengthCombo.h"
-#include "PanelStack.h"
-#include "qt_helpers.h"
-#include "Validator.h"
+#include "GuiView.h"
-// For the Branches module
-#include "GuiBranches.h"
-
-#include "GuiViewSource.h" // For latexHighlighter use in the preamble.
-
-#include "frontend_helpers.h"
+#include "BranchList.h"
+#include "buffer_funcs.h"
+#include "Buffer.h"
#include "BufferParams.h"
+#include "BufferView.h"
+#include "Color.h"
+#include "EmbeddedFiles.h"
#include "Encoding.h"
-#include "gettext.h"
+#include "FloatPlacement.h"
+#include "FuncRequest.h"
+#include "support/gettext.h"
+#include "GuiBranches.h"
#include "Language.h"
+#include "LaTeXFeatures.h"
+#include "LaTeXHighlighter.h"
+#include "Layout.h"
+#include "LengthCombo.h"
#include "LyXRC.h" // defaultUnit
-#include "TextClassList.h"
+#include "ModuleList.h"
+#include "OutputParams.h"
+#include "PanelStack.h"
+#include "PDFOptions.h"
+#include "qt_helpers.h"
#include "Spacing.h"
+#include "TextClassList.h"
+#include "Validator.h"
#include "insets/InsetListingsParams.h"
+#include "support/FileName.h"
+#include "support/filetools.h"
#include "support/lstrings.h"
#include <boost/bind.hpp>
#include <QTextCursor>
#include <algorithm>
-
-using lyx::support::token;
-using lyx::support::bformat;
-using lyx::support::findToken;
-using lyx::support::getVectorFromString;
+#include <sstream>
using std::distance;
using std::make_pair;
using std::pair;
using std::vector;
using std::string;
-
+using std::ostringstream;
+using std::sort;
///
template<class Pair>
namespace lyx {
namespace frontend {
+using support::token;
+using support::bformat;
+using support::findToken;
+using support::getVectorFromString;
+
/////////////////////////////////////////////////////////////////////
//
// PreambleModule
-GuiDocumentDialog::GuiDocumentDialog(LyXView & lv)
+GuiDocument::GuiDocument(GuiView & lv)
: GuiDialog(lv, "document")
{
setupUi(this);
- setController(new ControlDocument(*this));
setViewTitle(_("Document Settings"));
lang_ = getSecond(getLanguageData(false));
for (int n = 0; tex_fonts_roman[n][0]; ++n) {
QString font = qt_(tex_fonts_roman_gui[n]);
- if (!controller().isFontAvailable(tex_fonts_roman[n]))
+ if (!isFontAvailable(tex_fonts_roman[n]))
font += qt_(" (not installed)");
fontModule->fontsRomanCO->addItem(font);
}
for (int n = 0; tex_fonts_sans[n][0]; ++n) {
QString font = qt_(tex_fonts_sans_gui[n]);
- if (!controller().isFontAvailable(tex_fonts_sans[n]))
+ if (!isFontAvailable(tex_fonts_sans[n]))
font += qt_(" (not installed)");
fontModule->fontsSansCO->addItem(font);
}
for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
QString font = qt_(tex_fonts_monospaced_gui[n]);
- if (!controller().isFontAvailable(tex_fonts_monospaced[n]))
+ if (!isFontAvailable(tex_fonts_monospaced[n]))
font += qt_(" (not installed)");
fontModule->fontsTypewriterCO->addItem(font);
}
fontModule->fontsizeCO->addItem(qt_("11"));
fontModule->fontsizeCO->addItem(qt_("12"));
- for (int n = 0; ControlDocument::fontfamilies_gui[n][0]; ++n)
+ for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
fontModule->fontsDefaultCO->addItem(
- qt_(ControlDocument::fontfamilies_gui[n]));
+ qt_(GuiDocument::fontfamilies_gui[n]));
pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
}
// latex classes
//FIXME This seems too involved with the kernel. Some of this
- //should be moved to the controller---which should perhaps just
+ //should be moved to the kernel---which should perhaps just
//give us a list of entries or something of the sort.
for (TextClassList::const_iterator cit = textclasslist.begin();
cit != textclasslist.end(); ++cit) {
connect(bulletsModule, SIGNAL(changed()),
this, SLOT(change_adaptor()));
+ // embedded files
+ embeddedFilesModule = new UiWidget<Ui::EmbeddedFilesUi>;
+ connect(embeddedFilesModule->bundleCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(embeddedFilesModule->addPB, SIGNAL(clicked()),
+ this, SLOT(change_adaptor()));
+ connect(embeddedFilesModule->removePB, SIGNAL(clicked()),
+ this, SLOT(change_adaptor()));
+
+ // PDF support
+ pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
+
+ connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->titleLE, SIGNAL(textChanged(const QString &)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->authorLE, SIGNAL(textChanged(const QString &)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(const QString &)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(const QString &)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->backrefCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->pagebackrefCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
+ this, SLOT(change_adaptor()));
+ connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(const QString &)),
+ this, SLOT(change_adaptor()));
// float
floatModule = new FloatPlacement;
docPS->addPanel(langModule, _("Language"));
docPS->addPanel(numberingModule, _("Numbering & TOC"));
docPS->addPanel(biblioModule, _("Bibliography"));
+ docPS->addPanel(pdfSupportModule, _("PDF Properties"));
docPS->addPanel(mathsModule, _("Math Options"));
docPS->addPanel(floatModule, _("Float Placement"));
docPS->addPanel(bulletsModule, _("Bullets"));
docPS->addPanel(branchesModule, _("Branches"));
+ docPS->addPanel(embeddedFilesModule, _("Embedded Files"));
docPS->addPanel(preambleModule, _("LaTeX Preamble"));
docPS->setCurrentPanel(_("Document Class"));
// FIXME: hack to work around resizing bug in Qt >= 4.2
}
-ControlDocument & GuiDocumentDialog::controller()
-{
- return static_cast<ControlDocument &>(GuiDialog::controller());
-}
-
-
-void GuiDocumentDialog::showPreamble()
+void GuiDocument::showPreamble()
{
docPS->setCurrentPanel(_("LaTeX Preamble"));
}
-void GuiDocumentDialog::saveDefaultClicked()
+void GuiDocument::saveDefaultClicked()
{
saveDocDefault();
}
-void GuiDocumentDialog::useDefaultsClicked()
+void GuiDocument::useDefaultsClicked()
{
useClassDefaults();
}
-void GuiDocumentDialog::change_adaptor()
+void GuiDocument::change_adaptor()
{
changed();
}
-docstring GuiDocumentDialog::validate_listings_params()
+docstring GuiDocument::validate_listings_params()
{
// use a cache here to avoid repeated validation
// of the same parameters
}
-void GuiDocumentDialog::set_listings_msg()
+void GuiDocument::set_listings_msg()
{
static bool isOK = true;
docstring msg = validate_listings_params();
}
-void GuiDocumentDialog::closeEvent(QCloseEvent * e)
+void GuiDocument::closeEvent(QCloseEvent * e)
{
slotClose();
e->accept();
}
-void GuiDocumentDialog::setLSpacing(int item)
+void GuiDocument::setLSpacing(int item)
{
textLayoutModule->lspacingLE->setEnabled(item == 3);
}
-void GuiDocumentDialog::setSkip(int item)
+void GuiDocument::setSkip(int item)
{
bool const enable = (item == 3);
textLayoutModule->skipLE->setEnabled(enable);
}
-void GuiDocumentDialog::enableSkip(bool skip)
+void GuiDocument::enableSkip(bool skip)
{
textLayoutModule->skipCO->setEnabled(skip);
textLayoutModule->skipLE->setEnabled(skip);
setSkip(textLayoutModule->skipCO->currentIndex());
}
-void GuiDocumentDialog::portraitChanged()
+void GuiDocument::portraitChanged()
{
setMargins(pageLayoutModule->papersizeCO->currentIndex());
}
-void GuiDocumentDialog::setMargins(bool custom)
+void GuiDocument::setMargins(bool custom)
{
marginsModule->marginCB->setChecked(custom);
setCustomMargins(custom);
}
-void GuiDocumentDialog::setCustomPapersize(int papersize)
+void GuiDocument::setCustomPapersize(int papersize)
{
bool const custom = (papersize == 1);
}
-void GuiDocumentDialog::setCustomMargins(bool custom)
+void GuiDocument::setCustomMargins(bool custom)
{
marginsModule->topL->setEnabled(!custom);
marginsModule->topLE->setEnabled(!custom);
}
-void GuiDocumentDialog::updateFontsize(string const & items, string const & sel)
+void GuiDocument::updateFontsize(string const & items, string const & sel)
{
fontModule->fontsizeCO->clear();
fontModule->fontsizeCO->addItem(qt_("Default"));
}
-void GuiDocumentDialog::romanChanged(int item)
+void GuiDocument::romanChanged(int item)
{
string const font = tex_fonts_roman[item];
- fontModule->fontScCB->setEnabled(controller().providesSC(font));
- fontModule->fontOsfCB->setEnabled(controller().providesOSF(font));
+ fontModule->fontScCB->setEnabled(providesSC(font));
+ fontModule->fontOsfCB->setEnabled(providesOSF(font));
}
-void GuiDocumentDialog::sansChanged(int item)
+void GuiDocument::sansChanged(int item)
{
string const font = tex_fonts_sans[item];
- bool scaleable = controller().providesScale(font);
+ bool scaleable = providesScale(font);
fontModule->scaleSansSB->setEnabled(scaleable);
fontModule->scaleSansLA->setEnabled(scaleable);
}
-void GuiDocumentDialog::ttChanged(int item)
+void GuiDocument::ttChanged(int item)
{
string const font = tex_fonts_monospaced[item];
- bool scaleable = controller().providesScale(font);
+ bool scaleable = providesScale(font);
fontModule->scaleTypewriterSB->setEnabled(scaleable);
fontModule->scaleTypewriterLA->setEnabled(scaleable);
}
-void GuiDocumentDialog::updatePagestyle(string const & items, string const & sel)
+void GuiDocument::updatePagestyle(string const & items, string const & sel)
{
pagestyles.clear();
pageLayoutModule->pagestyleCO->clear();
}
-void GuiDocumentDialog::classChanged()
+void GuiDocument::classChanged()
{
- BufferParams & params = controller().params();
textclass_type const tc = latexModule->classCO->currentIndex();
- params.setJustBaseClass(tc);
+ bp_.setJustBaseClass(tc);
if (lyxrc.auto_reset_options)
- params.useClassDefaults();
+ bp_.useClassDefaults();
updateContents();
}
-void GuiDocumentDialog::updateModuleInfo()
+void GuiDocument::updateModuleInfo()
{
selectionManager->update();
//Module description
else {
QModelIndex const idx = lv->selectionModel()->currentIndex();
string const modName = fromqstr(idx.data().toString());
- string desc = controller().getModuleDescription(modName);
- vector<string> pkgList = controller().getPackageList(modName);
+ string desc = getModuleDescription(modName);
+ vector<string> pkgList = getPackageList(modName);
string pkgdesc;
//this mess formats the package list as "pkg1, pkg2, and pkg3"
int const pkgListSize = pkgList.size();
}
-void GuiDocumentDialog::updateNumbering()
+void GuiDocument::updateEmbeddedFileList()
{
- TextClass const & tclass = controller().params().getTextClass();
+ embeddedFilesModule->filesLW->clear();
+ // add current embedded files
+ EmbeddedFiles & files = buffer().embeddedFiles();
+ files.update();
+ EmbeddedFiles::EmbeddedFileList::iterator fit = files.begin();
+ EmbeddedFiles::EmbeddedFileList::iterator fit_end = files.end();
+ for (; fit != fit_end; ++fit) {
+ QString label = toqstr(fit->relFilename(buffer().filePath()));
+ if (fit->refCount() > 1)
+ label += " (" + QString::number(fit->refCount()) + ")";
+ QListWidgetItem * item = new QListWidgetItem(label);
+ item->setFlags(item->flags() | Qt::ItemIsSelectable
+ | Qt::ItemIsUserCheckable);
+ if(fit->embedded())
+ item->setCheckState(Qt::Checked);
+ else
+ item->setCheckState(Qt::Unchecked);
+ // index of the currently used ParConstIterator
+ embeddedFilesModule->filesLW->addItem(item);
+ }
+}
+
+
+void GuiDocument::updateNumbering()
+{
+ TextClass const & tclass = bp_.getTextClass();
numberingModule->tocTW->setUpdatesEnabled(false);
numberingModule->tocTW->clear();
numberingModule->tocTW->update();
}
-void GuiDocumentDialog::apply(BufferParams & params)
+
+void GuiDocument::apply(BufferParams & params)
{
// preamble
preambleModule->apply(params);
params.fontsOSF = fontModule->fontOsfCB->isChecked();
- params.fontsDefaultFamily = ControlDocument::fontfamilies[
+ params.fontsDefaultFamily = GuiDocument::fontfamilies[
fontModule->fontsDefaultCO->currentIndex()];
if (fontModule->fontsizeCO->currentIndex() == 0)
pageLayoutModule->paperheightUnitCO);
if (pageLayoutModule->facingPagesCB->isChecked())
- params.sides = TextClass::TwoSides;
+ params.sides = TwoSides;
else
- params.sides = TextClass::OneSide;
+ params.sides = OneSide;
if (pageLayoutModule->landscapeRB->isChecked())
params.orientation = ORIENTATION_LANDSCAPE;
Ui::MarginsUi const * m(marginsModule);
params.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
-
params.topmargin = widgetsToLength(m->topLE, m->topUnit);
-
params.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
-
params.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
-
params.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
-
params.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
-
params.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
branchesModule->apply(params);
+
+ // PDF support
+ PDFOptions & pdf = params.pdfoptions();
+ pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
+ pdf.title = fromqstr(pdfSupportModule->titleLE->text());
+ pdf.author = fromqstr(pdfSupportModule->authorLE->text());
+ pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
+ pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
+
+ pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
+ pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
+ pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
+ pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
+
+ pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
+ pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
+ pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
+ pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
+ pdf.backref = pdfSupportModule->backrefCB->isChecked();
+ pdf.pagebackref = pdfSupportModule->pagebackrefCB->isChecked();
+ if (pdfSupportModule->fullscreenCB->isChecked())
+ pdf.pagemode = pdf.pagemode_fullscreen;
+ else
+ pdf.pagemode.clear();
+ pdf.quoted_options = fromqstr(pdfSupportModule->optionsLE->text());
+
+ // Embedded files
+ // FIXME
+
+ // GuiDocument is special because some change in there might affect other
+ // dialogs. It is then better to make sure that all dialogs are in sync
+ // with current document settings.
+ lyxview().updateBufferDependent(true);
+ lyxview().updateLayoutList();
+ lyxview().updateToolbars();
}
}
-void GuiDocumentDialog::updateParams()
+void GuiDocument::updateParams()
{
- BufferParams const & params = controller().params();
- updateParams(params);
+ updateParams(bp_);
}
-void GuiDocumentDialog::updateParams(BufferParams const & params)
+void GuiDocument::updateParams(BufferParams const & params)
{
// set the default unit
- // FIXME: move to controller
Length::UNIT defaultUnit = Length::CM;
switch (lyxrc.default_papersize) {
case PAPER_DEFAULT: break;
}
// preamble
- preambleModule->update(params, controller().id());
+ preambleModule->update(params, id());
// biblio
biblioModule->citeDefaultRB->setChecked(
langModule->otherencodingRB->setChecked(!default_enc);
// numbering
- int const min_toclevel = controller().textClass().min_toclevel();
- int const max_toclevel = controller().textClass().max_toclevel();
- if (controller().textClass().hasTocLevels()) {
+ int const min_toclevel = textClass().min_toclevel();
+ int const max_toclevel = textClass().max_toclevel();
+ if (textClass().hasTocLevels()) {
numberingModule->setEnabled(true);
numberingModule->depthSL->setMinimum(min_toclevel - 1);
numberingModule->depthSL->setMaximum(max_toclevel);
// text layout
latexModule->classCO->setCurrentIndex(params.getBaseClass());
- updatePagestyle(controller().textClass().opt_pagestyle(),
+ updatePagestyle(textClass().opt_pagestyle(),
params.pagestyle);
textLayoutModule->lspacingCO->setCurrentIndex(nitem);
floatModule->set(params.float_placement);
// Fonts
- updateFontsize(controller().textClass().opt_fontsize(),
+ updateFontsize(textClass().opt_fontsize(),
params.fontsize);
int n = findToken(tex_fonts_roman, params.fontsRoman);
fontModule->fontOsfCB->setChecked(params.fontsOSF);
fontModule->scaleSansSB->setValue(params.fontsSansScale);
fontModule->scaleTypewriterSB->setValue(params.fontsTypewriterScale);
- n = findToken(ControlDocument::fontfamilies, params.fontsDefaultFamily);
+ n = findToken(GuiDocument::fontfamilies, params.fontsDefaultFamily);
if (n >= 0)
fontModule->fontsDefaultCO->setCurrentIndex(n);
pageLayoutModule->portraitRB->setChecked(!landscape);
pageLayoutModule->facingPagesCB->setChecked(
- params.sides == TextClass::TwoSides);
+ params.sides == TwoSides);
lengthToWidgets(pageLayoutModule->paperwidthLE,
params.footskip, defaultUnit);
branchesModule->update(params);
+
+ // PDF support
+ PDFOptions const & pdf = params.pdfoptions();
+ pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
+ pdfSupportModule->titleLE->setText(toqstr(pdf.title));
+ pdfSupportModule->authorLE->setText(toqstr(pdf.author));
+ pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
+ pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
+
+ pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
+ pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
+ pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
+
+ pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
+
+ pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
+ pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
+ pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
+ pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
+ pdfSupportModule->backrefCB->setChecked(pdf.backref);
+ pdfSupportModule->pagebackrefCB->setChecked(pdf.pagebackref);
+ pdfSupportModule->fullscreenCB->setChecked
+ (pdf.pagemode == pdf.pagemode_fullscreen);
+
+ pdfSupportModule->optionsLE->setText(
+ toqstr(pdf.quoted_options));
+
+ // embedded files
+ updateEmbeddedFileList();
}
-void GuiDocumentDialog::applyView()
+void GuiDocument::applyView()
{
- apply(controller().params());
+ apply(params());
}
-void GuiDocumentDialog::saveDocDefault()
+void GuiDocument::saveDocDefault()
{
// we have to apply the params first
applyView();
- controller().saveAsDefault();
+ saveAsDefault();
}
-void GuiDocumentDialog::updateContents()
+void GuiDocument::updateContents()
{
//update list of available modules
QStringList strlist;
- vector<string> const modNames = controller().getModuleNames();
+ vector<string> const modNames = getModuleNames();
vector<string>::const_iterator it = modNames.begin();
for (; it != modNames.end(); ++it)
strlist.push_back(toqstr(*it));
available_model_.setStringList(strlist);
//and selected ones, too
QStringList strlist2;
- vector<string> const & selMods = controller().getSelectedModules();
+ vector<string> const & selMods = getSelectedModules();
it = selMods.begin();
for (; it != selMods.end(); ++it)
strlist2.push_back(toqstr(*it));
selected_model_.setStringList(strlist2);
- updateParams(controller().params());
+ updateParams(bp_);
}
-void GuiDocumentDialog::useClassDefaults()
+void GuiDocument::useClassDefaults()
{
- BufferParams & params = controller().params();
-
- params.setJustBaseClass(latexModule->classCO->currentIndex());
- params.useClassDefaults();
+ bp_.setJustBaseClass(latexModule->classCO->currentIndex());
+ bp_.useClassDefaults();
updateContents();
}
-bool GuiDocumentDialog::isValid()
+bool GuiDocument::isValid()
{
return validate_listings_params().empty();
}
+char const * const GuiDocument::fontfamilies[5] = {
+ "default", "rmdefault", "sfdefault", "ttdefault", ""
+};
+
+
+char const * GuiDocument::fontfamilies_gui[5] = {
+ N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
+};
+
+
+bool GuiDocument::initialiseParams(string const &)
+{
+ bp_ = buffer().params();
+ loadModuleNames();
+ return true;
+}
+
+
+void GuiDocument::clearParams()
+{
+ bp_ = BufferParams();
+}
+
+
+BufferId GuiDocument::id() const
+{
+ return &buffer();
+}
+
+
+vector<string> GuiDocument::getModuleNames()
+{
+ return moduleNames_;
+}
+
+
+vector<string> const & GuiDocument::getSelectedModules()
+{
+ return params().getModules();
+}
+
+
+string GuiDocument::getModuleDescription(string const & modName) const
+{
+ LyXModule const * const mod = moduleList[modName];
+ if (!mod)
+ return string("Module unavailable!");
+ return mod->description;
+}
+
+
+vector<string>
+GuiDocument::getPackageList(string const & modName) const
+{
+ LyXModule const * const mod = moduleList[modName];
+ if (!mod)
+ return vector<string>(); //empty such thing
+ return mod->packageList;
+}
+
+
+TextClass const & GuiDocument::textClass() const
+{
+ return textclasslist[bp_.getBaseClass()];
+}
+
+
+static void dispatch_bufferparams(Dialog const & dialog,
+ BufferParams const & bp, kb_action lfun)
+{
+ ostringstream ss;
+ ss << "\\begin_header\n";
+ bp.writeFile(ss);
+ ss << "\\end_header\n";
+ dialog.dispatch(FuncRequest(lfun, ss.str()));
+}
+
+
+void GuiDocument::dispatchParams()
+{
+ // This must come first so that a language change is correctly noticed
+ setLanguage();
+
+ // Apply the BufferParams. Note that this will set the base class
+ // and then update the buffer's layout.
+ //FIXME Could this be done last? Then, I think, we'd get the automatic
+ //update mentioned in the next FIXME...
+ dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
+
+ // Generate the colours requested by each new branch.
+ BranchList & branchlist = params().branchlist();
+ if (!branchlist.empty()) {
+ BranchList::const_iterator it = branchlist.begin();
+ BranchList::const_iterator const end = branchlist.end();
+ for (; it != end; ++it) {
+ docstring const & current_branch = it->getBranch();
+ Branch const * branch = branchlist.find(current_branch);
+ string const x11hexname = X11hexname(branch->getColor());
+ // display the new color
+ docstring const str = current_branch + ' ' + from_ascii(x11hexname);
+ dispatch(FuncRequest(LFUN_SET_COLOR, str));
+ }
+
+ // Open insets of selected branches, close deselected ones
+ dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
+ "assign branch"));
+ }
+ // FIXME: If we used an LFUN, we would not need those two lines:
+ bufferview()->processUpdateFlags(Update::Force | Update::FitCursor);
+}
+
+
+void GuiDocument::setLanguage() const
+{
+ Language const * const newL = bp_.language;
+ if (buffer().params().language == newL)
+ return;
+
+ string const & lang_name = newL->lang();
+ dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
+}
+
+
+void GuiDocument::saveAsDefault() const
+{
+ dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
+}
+
+
+bool GuiDocument::isFontAvailable(string const & font) const
+{
+ if (font == "default" || font == "cmr"
+ || font == "cmss" || font == "cmtt")
+ // these are standard
+ return true;
+ if (font == "lmodern" || font == "lmss" || font == "lmtt")
+ return LaTeXFeatures::isAvailable("lmodern");
+ if (font == "times" || font == "palatino"
+ || font == "helvet" || font == "courier")
+ return LaTeXFeatures::isAvailable("psnfss");
+ if (font == "cmbr" || font == "cmtl")
+ return LaTeXFeatures::isAvailable("cmbright");
+ if (font == "utopia")
+ return LaTeXFeatures::isAvailable("utopia")
+ || LaTeXFeatures::isAvailable("fourier");
+ if (font == "beraserif" || font == "berasans"
+ || font == "beramono")
+ return LaTeXFeatures::isAvailable("bera");
+ return LaTeXFeatures::isAvailable(font);
+}
+
+
+bool GuiDocument::providesOSF(string const & font) const
+{
+ if (font == "cmr")
+ return isFontAvailable("eco");
+ if (font == "palatino")
+ return isFontAvailable("mathpazo");
+ return false;
+}
+
+
+bool GuiDocument::providesSC(string const & font) const
+{
+ if (font == "palatino")
+ return isFontAvailable("mathpazo");
+ if (font == "utopia")
+ return isFontAvailable("fourier");
+ return false;
+}
+
+
+bool GuiDocument::providesScale(string const & font) const
+{
+ return font == "helvet" || font == "luximono"
+ || font == "berasans" || font == "beramono";
+}
+
+
+void GuiDocument::loadModuleNames ()
+{
+ moduleNames_.clear();
+ LyXModuleList::const_iterator it = moduleList.begin();
+ for (; it != moduleList.end(); ++it)
+ moduleNames_.push_back(it->name);
+ if (!moduleNames_.empty())
+ sort(moduleNames_.begin(), moduleNames_.end());
+}
+
+
+Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
+
+
} // namespace frontend
} // namespace lyx
projects / lyx.git / blobdiff