#include "BufferParams.h"
#include "BufferView.h"
#include "Color.h"
+#include "ColorCache.h"
#include "Encoding.h"
#include "FloatPlacement.h"
+#include "Format.h"
#include "FuncRequest.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "Layout.h"
-#include "LyXRC.h" // defaultUnit
+#include "LayoutModuleList.h"
+#include "LyXRC.h"
#include "ModuleList.h"
#include "OutputParams.h"
#include "PDFOptions.h"
#include "frontends/alert.h"
#include <QAbstractItemModel>
+#include <QColor>
+#include <QColorDialog>
#include <QCloseEvent>
+#include <QFontDatabase>
#include <QScrollBar>
#include <QTextCursor>
#endif
+// a style sheet for buttons
+// this is for example used for the background color setting button
+static inline QString colorButtonStyleSheet(QColor const & bgColor)
+{
+ if (bgColor.isValid()) {
+ QString rc = QLatin1String("background:");
+ rc += bgColor.name();
+ return rc;
+ }
+ return QLatin1String("");
+}
+
+
using namespace std;
using namespace lyx::support;
namespace lyx {
+RGBColor set_backgroundcolor;
+
namespace {
// used when sorting the textclass list.
class less_textclass_avail_desc
// 2. Description (lexicographic)
LayoutFile const & tc1 = LayoutFileList::get()[lhs];
LayoutFile const & tc2 = LayoutFileList::get()[rhs];
+ int const rel = compare_no_case(
+ translateIfPossible(from_utf8(tc1.description())),
+ translateIfPossible(from_utf8(tc2.description())));
return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
- (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() &&
- translateIfPossible(from_utf8(tc1.description()))
- < translateIfPossible(from_utf8(tc2.description())));
+ (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && rel < 0);
}
};
upPB, downPB, availableModel, selectedModel), container_(container)
{}
///
- void updateProvidedModules(std::list<std::string> const & pm)
- { provided_modules_ = pm; }
+ void updateProvidedModules(LayoutModuleList const & pm)
+ { provided_modules_ = pm.list(); }
///
- void updateExcludedModules(std::list<std::string> const & em)
- { excluded_modules_ = em; }
+ void updateExcludedModules(LayoutModuleList const & em)
+ { excluded_modules_ = em.list(); }
private:
///
virtual void updateAddPB();
// initialize the length validator
bc().addCheckedLineEdit(textLayoutModule->skipLE);
- fontModule = new UiWidget<Ui::FontUi>;
+ // output
+ outputModule = new UiWidget<Ui::OutputUi>;
+
+ connect(outputModule->xetexCB, SIGNAL(clicked()),
+ this, SLOT(change_adaptor()));
+ connect(outputModule->xetexCB, SIGNAL(toggled(bool)),
+ this, SLOT(xetexChanged(bool)));
+ connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
+ this, SLOT(change_adaptor()));
+
// fonts
+ fontModule = new UiWidget<Ui::FontUi>;
connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
this, SLOT(change_adaptor()));
connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
connect(fontModule->fontOsfCB, SIGNAL(clicked()),
this, SLOT(change_adaptor()));
- for (int n = 0; tex_fonts_roman[n][0]; ++n) {
- QString font = qt_(tex_fonts_roman_gui[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 (!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 (!isFontAvailable(tex_fonts_monospaced[n]))
- font += qt_(" (not installed)");
- fontModule->fontsTypewriterCO->addItem(font);
- }
+ updateFontlist();
fontModule->fontsizeCO->addItem(qt_("Default"));
fontModule->fontsizeCO->addItem(qt_("10"));
this, SLOT(change_adaptor()));
connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
this, SLOT(change_adaptor()));
+ connect(pageLayoutModule->backgroundTB, SIGNAL(clicked()),
+ this, SLOT(changeBackgroundColor()));
+ connect(pageLayoutModule->delbackgroundTB, SIGNAL(clicked()),
+ this, SLOT(deleteBackgroundColor()));
pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
docPS->addPanel(floatModule, qt_("Float Placement"));
docPS->addPanel(bulletsModule, qt_("Bullets"));
docPS->addPanel(branchesModule, qt_("Branches"));
+ docPS->addPanel(outputModule, qt_("Output"));
docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
docPS->setCurrentPanel(qt_("Document Class"));
// FIXME: hack to work around resizing bug in Qt >= 4.2
setSkip(textLayoutModule->skipCO->currentIndex());
}
+
void GuiDocument::portraitChanged()
{
setMargins(pageLayoutModule->papersizeCO->currentIndex());
}
+
void GuiDocument::setMargins(bool custom)
{
+ bool const extern_geometry =
+ documentClass().provides("geometry");
+ marginsModule->marginCB->setEnabled(!extern_geometry);
+ if (extern_geometry) {
+ marginsModule->marginCB->setChecked(false);
+ setCustomMargins(true);
+ return;
+ }
marginsModule->marginCB->setChecked(custom);
setCustomMargins(custom);
}
marginsModule->columnsepUnit->setEnabled(enableColSep);
}
+void GuiDocument::changeBackgroundColor()
+{
+ QColor const & newColor = QColorDialog::getColor(
+ rgb2qcolor(set_backgroundcolor), qApp->focusWidget());
+ if (!newColor.isValid())
+ return;
+ // set the button color
+ pageLayoutModule->backgroundTB->setStyleSheet(
+ colorButtonStyleSheet(newColor));
+ // save color
+ set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
+ changed();
+}
+
+
+void GuiDocument::deleteBackgroundColor()
+{
+ // set the button color back to white
+ pageLayoutModule->backgroundTB->setStyleSheet(
+ colorButtonStyleSheet(QColor(Qt::white)));
+ // save white as the set color
+ set_backgroundcolor = rgbFromHexName("#ffffff");
+ changed();
+}
+
+
+void GuiDocument::xetexChanged(bool xetex)
+{
+ updateFontlist();
+ updateDefaultFormat();
+ langModule->encodingCO->setEnabled(!xetex &&
+ !langModule->defaultencodingRB->isChecked());
+ langModule->defaultencodingRB->setEnabled(!xetex);
+ langModule->otherencodingRB->setEnabled(!xetex);
+
+ fontModule->fontsDefaultCO->setEnabled(!xetex);
+ fontModule->fontsDefaultLA->setEnabled(!xetex);
+ fontModule->cjkFontLE->setEnabled(!xetex);
+ fontModule->cjkFontLA->setEnabled(!xetex);
+ string font;
+ if (!xetex)
+ font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
+ bool scaleable = providesScale(font);
+ fontModule->scaleSansSB->setEnabled(scaleable);
+ fontModule->scaleSansLA->setEnabled(scaleable);
+ if (!xetex)
+ font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
+ scaleable = providesScale(font);
+ fontModule->scaleTypewriterSB->setEnabled(scaleable);
+ fontModule->scaleTypewriterLA->setEnabled(scaleable);
+ if (!xetex)
+ font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
+ fontModule->fontScCB->setEnabled(providesSC(font));
+ fontModule->fontOsfCB->setEnabled(providesOSF(font));
+}
+
void GuiDocument::updateFontsize(string const & items, string const & sel)
{
}
+void GuiDocument::updateFontlist()
+{
+ fontModule->fontsRomanCO->clear();
+ fontModule->fontsSansCO->clear();
+ fontModule->fontsTypewriterCO->clear();
+
+ // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
+ if (outputModule->xetexCB->isChecked()) {
+ fontModule->fontsRomanCO->addItem(qt_("Default"));
+ fontModule->fontsSansCO->addItem(qt_("Default"));
+ fontModule->fontsTypewriterCO->addItem(qt_("Default"));
+
+ QFontDatabase fontdb;
+ QStringList families(fontdb.families());
+ for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
+ fontModule->fontsRomanCO->addItem(*it);
+ fontModule->fontsSansCO->addItem(*it);
+ fontModule->fontsTypewriterCO->addItem(*it);
+ }
+ return;
+ }
+
+ for (int n = 0; tex_fonts_roman[n][0]; ++n) {
+ QString font = qt_(tex_fonts_roman_gui[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 (!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 (!isFontAvailable(tex_fonts_monospaced[n]))
+ font += qt_(" (not installed)");
+ fontModule->fontsTypewriterCO->addItem(font);
+ }
+}
+
+
void GuiDocument::romanChanged(int item)
{
+ if (outputModule->xetexCB->isChecked())
+ return;
string const font = tex_fonts_roman[item];
fontModule->fontScCB->setEnabled(providesSC(font));
fontModule->fontOsfCB->setEnabled(providesOSF(font));
void GuiDocument::sansChanged(int item)
{
+ if (outputModule->xetexCB->isChecked())
+ return;
string const font = tex_fonts_sans[item];
bool scaleable = providesScale(font);
fontModule->scaleSansSB->setEnabled(scaleable);
void GuiDocument::ttChanged(int item)
{
+ if (outputModule->xetexCB->isChecked())
+ return;
string const font = tex_fonts_monospaced[item];
bool scaleable = providesScale(font);
fontModule->scaleTypewriterSB->setEnabled(scaleable);
if (v.size() == 0)
return docstring();
if (v.size() == 1)
- return from_ascii(v[0]);
+ return from_utf8(v[0]);
if (v.size() == 2) {
docstring retval = _("%1$s and %2$s");
retval = subst(retval, _("and"), s);
- return bformat(retval, from_ascii(v[0]), from_ascii(v[1]));
+ return bformat(retval, from_utf8(v[0]), from_utf8(v[1]));
}
// The idea here is to format all but the last two items...
int const vSize = v.size();
docstring t2 = _("%1$s, %2$s");
- docstring retval = from_ascii(v[0]);
+ docstring retval = from_utf8(v[0]);
for (int i = 1; i < vSize - 2; ++i)
- retval = bformat(t2, retval, from_ascii(v[i]));
+ retval = bformat(t2, retval, from_utf8(v[i]));
//...and then to plug them, and the last two, into this schema
docstring t = _("%1$s, %2$s, and %3$s");
t = subst(t, _("and"), s);
- return bformat(t, retval, from_ascii(v[vSize - 2]), from_ascii(v[vSize - 1]));
+ return bformat(t, retval, from_utf8(v[vSize - 2]), from_utf8(v[vSize - 1]));
}
vector<string> idsToNames(vector<string> const & idList)
// update the list of removed modules
bp.clearRemovedModules();
- list<string> const & reqmods = bp.baseClass()->defaultModules();
+ LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
list<string>::const_iterator rit = reqmods.begin();
list<string>::const_iterator ren = reqmods.end();
string const modName = id_model.getIDString(idx.row());
docstring desc = getModuleDescription(modName);
- list<string> const & provmods = bp_.baseClass()->providedModules();
+ LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
if (!desc.empty())
desc += "\n";
}
+void GuiDocument::updateDefaultFormat()
+{
+ // make a copy in order to consider unapplied changes
+ Buffer * tmpbuf = const_cast<Buffer *>(&buffer());
+ tmpbuf->params().useXetex = outputModule->xetexCB->isChecked();
+ int idx = latexModule->classCO->currentIndex();
+ if (idx >= 0) {
+ string const classname = classes_model_.getIDString(idx);
+ tmpbuf->params().setBaseClass(classname);
+ tmpbuf->params().makeDocumentClass();
+ }
+ outputModule->defaultFormatCO->blockSignals(true);
+ outputModule->defaultFormatCO->clear();
+ outputModule->defaultFormatCO->addItem(qt_("Default"),
+ QVariant(QString("default")));
+ typedef vector<Format const *> Formats;
+ Formats formats = tmpbuf->exportableFormats(true);
+ Formats::const_iterator cit = formats.begin();
+ Formats::const_iterator end = formats.end();
+ for (; cit != end; ++cit)
+ outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
+ QVariant(toqstr((*cit)->name())));
+ outputModule->defaultFormatCO->blockSignals(false);
+}
+
+
void GuiDocument::applyView()
{
// preamble
QString const lang = langModule->languageCO->itemData(
langModule->languageCO->currentIndex()).toString();
- bp_.language = lyx::languages.getLanguage(fromqstr(lang));
+ bp_.language = languages.getLanguage(fromqstr(lang));
// numbering
if (bp_.documentClass().hasTocLevels()) {
bp_.float_placement = floatModule->get();
- // fonts
- bp_.fontsRoman =
- tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
+ // output
+ bp_.defaultOutputFormat = fromqstr(outputModule->defaultFormatCO->itemData(
+ outputModule->defaultFormatCO->currentIndex()).toString());
- bp_.fontsSans =
- tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
+ bool const xetex = outputModule->xetexCB->isChecked();
+ bp_.useXetex = xetex;
- bp_.fontsTypewriter =
- tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
+ // fonts
+ if (xetex) {
+ if (fontModule->fontsRomanCO->currentIndex() == 0)
+ bp_.fontsRoman = "default";
+ else
+ bp_.fontsRoman =
+ fromqstr(fontModule->fontsRomanCO->currentText());
+
+ if (fontModule->fontsSansCO->currentIndex() == 0)
+ bp_.fontsSans = "default";
+ else
+ bp_.fontsSans =
+ fromqstr(fontModule->fontsSansCO->currentText());
+
+ if (fontModule->fontsTypewriterCO->currentIndex() == 0)
+ bp_.fontsTypewriter = "default";
+ else
+ bp_.fontsTypewriter =
+ fromqstr(fontModule->fontsTypewriterCO->currentText());
+ } else {
+ bp_.fontsRoman =
+ tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
+
+ bp_.fontsSans =
+ tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
+
+ bp_.fontsTypewriter =
+ tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
+ }
bp_.fontsCJK =
fromqstr(fontModule->cjkFontLE->text());
bp_.fontsOSF = fontModule->fontOsfCB->isChecked();
- bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
- fontModule->fontsDefaultCO->currentIndex()];
+ if (xetex)
+ bp_.fontsDefaultFamily = "default";
+ else
+ bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
+ fontModule->fontsDefaultCO->currentIndex()];
if (fontModule->fontsizeCO->currentIndex() == 0)
bp_.fontsize = "default";
else
bp_.orientation = ORIENTATION_PORTRAIT;
+ bp_.backgroundcolor = set_backgroundcolor;
+
// margins
bp_.use_geometry = !marginsModule->marginCB->isChecked()
|| geom_papersize;
void GuiDocument::paramsToDialog()
{
// set the default unit
- Length::UNIT defaultUnit = Length::CM;
- switch (lyxrc.default_papersize) {
- case PAPER_DEFAULT: break;
-
- case PAPER_USLETTER:
- case PAPER_USLEGAL:
- case PAPER_USEXECUTIVE:
- defaultUnit = Length::IN;
- break;
-
- case PAPER_A3:
- case PAPER_A4:
- case PAPER_A5:
- case PAPER_B3:
- case PAPER_B4:
- case PAPER_B5:
- defaultUnit = Length::CM;
- break;
- case PAPER_CUSTOM:
- break;
- }
+ Length::UNIT const defaultUnit = Length::defaultUnit();
// preamble
preambleModule->update(bp_, id());
floatModule->set(bp_.float_placement);
+ // Output
+ // update combobox with formats
+ updateDefaultFormat();
+ int index = outputModule->defaultFormatCO->findData(toqstr(
+ bp_.defaultOutputFormat));
+ // set to default if format is not found
+ if (index == -1)
+ index = 0;
+ outputModule->defaultFormatCO->setCurrentIndex(index);
+ outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
+ outputModule->xetexCB->setChecked(
+ bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
+
// Fonts
updateFontsize(documentClass().opt_fontsize(),
bp_.fontsize);
- int n = findToken(tex_fonts_roman, bp_.fontsRoman);
- if (n >= 0) {
- fontModule->fontsRomanCO->setCurrentIndex(n);
- romanChanged(n);
- }
-
- n = findToken(tex_fonts_sans, bp_.fontsSans);
- if (n >= 0) {
- fontModule->fontsSansCO->setCurrentIndex(n);
- sansChanged(n);
- }
-
- n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
- if (n >= 0) {
- fontModule->fontsTypewriterCO->setCurrentIndex(n);
- ttChanged(n);
+ if (bp_.useXetex) {
+ for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
+ if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
+ fontModule->fontsRomanCO->setCurrentIndex(i);
+ return;
+ }
+ }
+
+ for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
+ if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
+ fontModule->fontsSansCO->setCurrentIndex(i);
+ return;
+ }
+ }
+ for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
+ if (fontModule->fontsTypewriterCO->itemText(i) ==
+ toqstr(bp_.fontsTypewriter)) {
+ fontModule->fontsTypewriterCO->setCurrentIndex(i);
+ return;
+ }
+ }
+ } else {
+ int n = findToken(tex_fonts_roman, bp_.fontsRoman);
+ if (n >= 0) {
+ fontModule->fontsRomanCO->setCurrentIndex(n);
+ romanChanged(n);
+ }
+
+ n = findToken(tex_fonts_sans, bp_.fontsSans);
+ if (n >= 0) {
+ fontModule->fontsSansCO->setCurrentIndex(n);
+ sansChanged(n);
+ }
+
+ n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
+ if (n >= 0) {
+ fontModule->fontsTypewriterCO->setCurrentIndex(n);
+ ttChanged(n);
+ }
}
if (!bp_.fontsCJK.empty())
fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
- n = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
- if (n >= 0)
- fontModule->fontsDefaultCO->setCurrentIndex(n);
+
+ int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
+ if (nn >= 0)
+ fontModule->fontsDefaultCO->setCurrentIndex(nn);
// paper
+ bool const extern_geometry =
+ documentClass().provides("geometry");
int const psize = bp_.papersize;
pageLayoutModule->papersizeCO->setCurrentIndex(psize);
- setCustomPapersize(psize);
+ setCustomPapersize(!extern_geometry && psize);
+ pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
bool const landscape =
bp_.orientation == ORIENTATION_LANDSCAPE;
pageLayoutModule->landscapeRB->setChecked(landscape);
pageLayoutModule->portraitRB->setChecked(!landscape);
+ pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
+ pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
pageLayoutModule->facingPagesCB->setChecked(
bp_.sides == TwoSides);
+ pageLayoutModule->backgroundTB->setStyleSheet(
+ colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
+ set_backgroundcolor = bp_.backgroundcolor;
lengthToWidgets(pageLayoutModule->paperwidthLE,
pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
-
lengthToWidgets(pageLayoutModule->paperheightLE,
pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
- n = findToken(backref_opts, pdf.backref);
- if (n >= 0)
- pdfSupportModule->backrefCO->setCurrentIndex(n);
+ nn = findToken(backref_opts, pdf.backref);
+ if (nn >= 0)
+ pdfSupportModule->backrefCO->setCurrentIndex(nn);
pdfSupportModule->fullscreenCB->setChecked
(pdf.pagemode == pdf.pagemode_fullscreen);
pdfSupportModule->optionsLE->setText(
toqstr(pdf.quoted_options));
+
+ // Make sure that the bc is in the INITIAL state
+ if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
+ bc().restore();
}
list<GuiDocument::modInfoStruct> const
- GuiDocument::makeModuleInfo(list<string> const & mods)
+ GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
{
- list<string>::const_iterator it = mods.begin();
- list<string>::const_iterator end = mods.end();
+ LayoutModuleList::const_iterator it = mods.begin();
+ LayoutModuleList::const_iterator end = mods.end();
list<modInfoStruct> mInfo;
for (; it != end; ++it) {
modInfoStruct m;
support::onlyPath(buffer().absFileName()));
if (isLyXFilename(master_file.absFilename())) {
Buffer * master = checkAndLoadLyXFile(master_file);
- const_cast<Buffer &>(buffer()).setParent(master);
+ if (master) {
+ if (master->isChild(const_cast<Buffer *>(&buffer())))
+ const_cast<Buffer &>(buffer()).setParent(master);
+ else
+ Alert::warning(_("Assigned master does not include this file"),
+ bformat(_("You must include this file in the document\n"
+ "'%1$s' in order to use the master document\n"
+ "feature."), from_utf8(params().master)));
+ } else
+ Alert::warning(_("Could not load master"),
+ bformat(_("The master document '%1$s'\n"
+ "could not be loaded."),
+ from_utf8(params().master)));
}
}
bool GuiDocument::providesOSF(string const & font) const
{
+ if (outputModule->xetexCB->isChecked())
+ // FIXME: we should check if the fonts really
+ // have OSF support. But how?
+ return true;
if (font == "cmr")
return isFontAvailable("eco");
if (font == "palatino")
bool GuiDocument::providesSC(string const & font) const
{
+ if (outputModule->xetexCB->isChecked())
+ return false;
if (font == "palatino")
return isFontAvailable("mathpazo");
if (font == "utopia")
bool GuiDocument::providesScale(string const & font) const
{
+ if (outputModule->xetexCB->isChecked())
+ return true;
return font == "helvet" || font == "luximono"
|| font == "berasans" || font == "beramono";
}
} // namespace frontend
} // namespace lyx
-#include "GuiDocument_moc.cpp"
+#include "moc_GuiDocument.cpp"
projects / lyx.git / blobdiff