// Do not remove the comment below, so we get merge conflict in
// independent branches. Instead add your own.
-int const LYX_FORMAT = 415; //uwestoehr : support for package undertilde (bug 6622)
+int const LYX_FORMAT = 416; //uwestoehr : support for horizontal spaces (bug 7728)
typedef map<string, bool> DepClean;
typedef map<docstring, pair<InsetLabel const *, Buffer::References> > RefCache;
params().indiceslist().clear();
params().backgroundcolor = lyx::rgbFromHexName("#ffffff");
params().isbackgroundcolor = false;
- params().fontcolor = lyx::rgbFromHexName("#000000");
+ params().fontcolor = RGBColor(0, 0, 0);
params().isfontcolor = false;
- params().notefontcolor = lyx::rgbFromHexName("#cccccc");
- params().boxbgcolor = lyx::rgbFromHexName("#ff0000");
+ params().notefontcolor = RGBColor(0xCC, 0xCC, 0xCC);
+ params().boxbgcolor = RGBColor(0xFF, 0, 0);
params().html_latex_start.clear();
params().html_latex_end.clear();
params().html_math_img_scale = 1.0;
bool Buffer::makeLaTeXFile(FileName const & fname,
- string const & original_path,
OutputParams const & runparams_in,
bool output_preamble, bool output_body) const
{
try {
os.texrow().reset();
- writeLaTeXSource(os, original_path,
- runparams, output_preamble, output_body);
+ writeLaTeXSource(os, runparams, output_preamble, output_body);
}
catch (EncodingException & e) {
odocstringstream ods;
void Buffer::writeLaTeXSource(otexstream & os,
- string const & original_path,
OutputParams const & runparams_in,
bool const output_preamble, bool const output_body) const
{
}
LYXERR(Debug::INFO, "lyx document header finished");
- // There are a few differences between nice LaTeX and usual files:
- // usual is \batchmode and has a
- // special input@path to allow the including of figures
- // with either \input or \includegraphics (what figinsets do).
- // input@path is set when the actual parameter
- // original_path is set. This is done for usual tex-file, but not
- // for nice-latex-file. (Matthias 250696)
- // Note that input@path is only needed for something the user does
- // in the preamble, included .tex files or ERT, files included by
- // LyX work without it.
+ // With respect to nice LaTeX, usual files have \batchmode
if (output_preamble) {
if (!runparams.nice) {
// code for usual, NOT nice-latex-file
os << "\\batchmode\n"; // changed from \nonstopmode
}
- if (!original_path.empty()) {
- // FIXME UNICODE
- // We don't know the encoding of inputpath
- docstring const inputpath = from_utf8(support::latex_path(original_path));
- docstring uncodable_glyphs;
- Encoding const * const enc = runparams.encoding;
- if (enc) {
- for (size_t n = 0; n < inputpath.size(); ++n) {
- docstring const glyph =
- docstring(1, inputpath[n]);
- if (enc->latexChar(inputpath[n], true) != glyph) {
- LYXERR0("Uncodable character '"
- << glyph
- << "' in input path!");
- uncodable_glyphs += glyph;
- }
- }
- }
-
- // warn user if we found uncodable glyphs.
- if (!uncodable_glyphs.empty()) {
- frontend::Alert::warning(_("Uncodable character in file path"),
- support::bformat(_("The path of your document\n"
- "(%1$s)\n"
- "contains glyphs that are unknown in the\n"
- "current document encoding (namely %2$s).\n"
- "This will likely result in incomplete output.\n\n"
- "Choose an appropriate document encoding (such as utf8)\n"
- "or change the file path name."), inputpath, uncodable_glyphs));
- } else {
- os << "\\makeatletter\n"
- << "\\def\\input@path{{"
- << inputpath << "/}}\n"
- << "\\makeatother\n";
- }
- }
// get parent macros (if this buffer has a parent) which will be
// written at the document begin further down.
<< styleinfo
<< "</style>\n";
}
+
+ bool const needfg = params().fontcolor != RGBColor(0, 0, 0);
+ bool const needbg = params().backgroundcolor != RGBColor(OxFF, OxFF, OxFF);
+ if (needfg || needbg) {
+ os << "<style type='text/css'>\nbody {\n";
+ if (needfg)
+ os << " color: "
+ << from_ascii(X11hexname(params().fontcolor))
+ << ";\n";
+ if (needbg)
+ os << " background-color: "
+ << from_ascii(X11hexname(params().backgroundcolor))
+ << ";\n";
+ os << "}\n</style>\n";
+ }
os << "</head>\n<body>\n";
}
// get LaTeX-Filename
FileName const path(temppath());
string const name = addName(path.absFileName(), latexName());
- string const org_path = filePath();
PathChanger p(path); // path to LaTeX file
message(_("Running chktex..."));
runparams.flavor = OutputParams::LATEX;
runparams.nice = false;
runparams.linelen = lyxrc.plaintext_linelen;
- makeLaTeXFile(FileName(name), org_path, runparams);
+ makeLaTeXFile(FileName(name), runparams);
TeXErrors terr;
Chktex chktex(lyxrc.chktex_command, onlyFileName(name), filePath());
case LFUN_BUFFER_EXPORT: {
docstring const arg = cmd.argument();
- enable = arg == "custom" || params().isExportable(to_utf8(arg));
+ if (arg == "custom") {
+ enable = true;
+ break;
+ }
+ string format = to_utf8(arg);
+ size_t pos = format.find(' ');
+ if (pos != string::npos)
+ format = format.substr(0, pos);
+ enable = params().isExportable(format);
if (!enable)
flag.message(bformat(
_("Don't know how to export to format: %1$s"), arg));
break;
}
- case LFUN_BUFFER_LANGUAGE: {
- Language const * oldL = params().language;
- Language const * newL = languages.getLanguage(argument);
- if (!newL || oldL == newL)
- break;
- if (oldL->rightToLeft() == newL->rightToLeft() && !isMultiLingual()) {
- changeLanguage(oldL, newL);
- dr.forceBufferUpdate();
- }
- break;
- }
-
default:
dispatched = false;
break;
else {
// latex or literate
otexstream ots(os, d->texrow);
- writeLaTeXSource(ots, string(), runparams, true, true);
+ writeLaTeXSource(ots, runparams, true, true);
}
} else {
runparams.par_begin = par_begin;
}
-bool Buffer::doExport(string const & format, bool put_in_tempdir,
+bool Buffer::doExport(string const & target, bool put_in_tempdir,
bool includeall, string & result_file) const
{
+ OutputParams runparams(¶ms().encoding());
+ string format = target;
+ string filename;
+ size_t pos = target.find(' ');
+ if (pos != string::npos) {
+ filename = target.substr(pos + 1, target.length() - pos - 1);
+ format = target.substr(0, pos);
+ runparams.export_folder = FileName(filename).onlyPath().realPath();
+ FileName(filename).onlyPath().createPath();
+ }
MarkAsExporting exporting(this);
string backend_format;
- OutputParams runparams(¶ms().encoding());
runparams.flavor = OutputParams::LATEX;
runparams.linelen = lyxrc.plaintext_linelen;
runparams.includeall = includeall;
runparams.flavor = OutputParams::XETEX;
}
- string filename = latexName(false);
- filename = addName(temppath(), filename);
- filename = changeExtension(filename,
- formats.extension(backend_format));
+ if (filename.empty()) {
+ filename = latexName(false);
+ filename = addName(temppath(), filename);
+ filename = changeExtension(filename,
+ formats.extension(backend_format));
+ }
// Plain text backend
if (backend_format == "text") {
// LaTeX backend
else if (backend_format == format) {
runparams.nice = true;
- if (!makeLaTeXFile(FileName(filename), string(), runparams)) {
+ if (!makeLaTeXFile(FileName(filename), runparams)) {
if (d->cloned_buffer_) {
d->cloned_buffer_->d->errorLists["Export"] =
d->errorLists["Export"];
return false;
} else {
runparams.nice = false;
- if (!makeLaTeXFile(FileName(filename), filePath(), runparams)) {
+ if (!makeLaTeXFile(FileName(filename), runparams)) {
if (d->cloned_buffer_) {
d->cloned_buffer_->d->errorLists["Export"] =
d->errorLists["Export"];
// if format == "dvi") to the result dir.
vector<ExportedFile> const files =
runparams.exportdata->externalFiles(format);
- string const dest = onlyPath(result_file);
+ string const dest = runparams.export_folder.empty() ?
+ onlyPath(result_file) : runparams.export_folder;
bool use_force = use_gui ? lyxrc.export_overwrite == ALL_FILES
: force_overwrite == ALL_FILES;
CopyStatus status = use_force ? FORCE : SUCCESS;
vector<ExportedFile>::const_iterator const en = files.end();
for (; it != en && status != CANCEL; ++it) {
string const fmt = formats.getFormatFromFile(it->sourceName);
+ string fixedName = it->exportName;
+ if (!runparams.export_folder.empty()) {
+ // Relative pathnames starting with ../ will be sanitized
+ // if exporting to a different folder
+ while (fixedName.substr(0, 3) == "../")
+ fixedName = fixedName.substr(3, fixedName.length() - 3);
+ }
+ FileName fixedFileName = makeAbsPath(fixedName, dest);
+ fixedFileName.onlyPath().createPath();
status = copyFile(fmt, it->sourceName,
- makeAbsPath(it->exportName, dest),
- it->exportName, status == FORCE);
+ fixedFileName,
+ it->exportName, status == FORCE,
+ runparams.export_folder.empty());
}
if (status == CANCEL) {
}
-bool Buffer::doExport(string const & format, bool put_in_tempdir,
- bool includeall) const
+bool Buffer::doExport(string const & target, bool put_in_tempdir,
+ bool includeall) const
{
string result_file;
// (1) export with all included children (omit \includeonly)
- if (includeall && !doExport(format, put_in_tempdir, true, result_file))
+ if (includeall && !doExport(target, put_in_tempdir, true, result_file))
return false;
// (2) export with included children only
- return doExport(format, put_in_tempdir, false, result_file);
+ return doExport(target, put_in_tempdir, false, result_file);
}