#include "Chktex.h"
#include "Converter.h"
#include "Counters.h"
+#include "DispatchResult.h"
#include "DocIterator.h"
#include "Encoding.h"
#include "ErrorList.h"
#include "Exporter.h"
#include "Format.h"
#include "FuncRequest.h"
+#include "FuncStatus.h"
+#include "IndicesList.h"
#include "InsetIterator.h"
#include "InsetList.h"
#include "Language.h"
#include "ParagraphParameters.h"
#include "ParIterator.h"
#include "PDFOptions.h"
+#include "SpellChecker.h"
#include "sgml.h"
#include "TexRow.h"
#include "TexStream.h"
#include "Undo.h"
#include "VCBackend.h"
#include "version.h"
+#include "WordLangTuple.h"
#include "WordList.h"
#include "insets/InsetBibitem.h"
#include "support/lassert.h"
#include "support/convert.h"
#include "support/debug.h"
+#include "support/docstring_list.h"
#include "support/ExceptionMessage.h"
#include "support/FileName.h"
#include "support/FileNameList.h"
#include "support/os.h"
#include "support/Package.h"
#include "support/Path.h"
+#include "support/Systemcall.h"
#include "support/textutils.h"
#include "support/types.h"
// Do not remove the comment below, so we get merge conflict in
// independent branches. Instead add your own.
-int const LYX_FORMAT = 348; // uwestoehr: add support for \*phantom
+int const LYX_FORMAT = 352; // jspitzm: splitindex support
typedef map<string, bool> DepClean;
typedef map<docstring, pair<InsetLabel const *, Buffer::References> > RefCache;
+void showPrintError(string const & name)
+{
+ docstring str = bformat(_("Could not print the document %1$s.\n"
+ "Check that your printer is set up correctly."),
+ makeDisplayPath(name, 50));
+ Alert::error(_("Print document failed"), str);
+}
+
} // namespace anon
class BufferSet : public std::set<Buffer const *> {};
params().clearLayoutModules();
params().clearRemovedModules();
params().pdfoptions().clear();
+ params().indiceslist().clear();
for (int i = 0; i < 4; ++i) {
params().user_defined_bullet(i) = ITEMIZE_DEFAULTS[i];
return false;
}
- removeAutosaveFile(d->filename.absFilename());
+ removeAutosaveFile();
saveCheckSum(d->filename);
message(str + _(" done."));
bool Buffer::makeLaTeXFile(FileName const & fname,
string const & original_path,
- OutputParams const & runparams,
+ OutputParams const & runparams_in,
bool output_preamble, bool output_body) const
{
+ OutputParams runparams = runparams_in;
+ if (params().useXetex)
+ runparams.flavor = OutputParams::XETEX;
+
string const encoding = runparams.encoding->iconvName();
LYXERR(Debug::LATEX, "makeLaTeXFile encoding: " << encoding << "...");
}
-bool Buffer::dispatch(string const & command, bool * result)
+bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag)
+{
+ switch (cmd.action) {
+ case LFUN_BUFFER_EXPORT: {
+ docstring const arg = cmd.argument();
+ bool enable = arg == "custom" || isExportable(to_utf8(arg));
+ if (!enable)
+ flag.message(bformat(
+ _("Don't know how to export to format: %1$s"), arg));
+ flag.setEnabled(enable);
+ break;
+ }
+
+ case LFUN_BRANCH_ACTIVATE:
+ case LFUN_BRANCH_DEACTIVATE: {
+ BranchList const & branchList = params().branchlist();
+ docstring const branchName = cmd.argument();
+ flag.setEnabled(!branchName.empty()
+ && branchList.find(branchName));
+ break;
+ }
+
+ case LFUN_BUFFER_PRINT:
+ // if no Buffer is present, then of course we won't be called!
+ flag.setEnabled(true);
+ break;
+
+ default:
+ return false;
+ }
+ return true;
+}
+
+
+void Buffer::dispatch(string const & command, DispatchResult & result)
{
return dispatch(lyxaction.lookupFunc(command), result);
}
-bool Buffer::dispatch(FuncRequest const & func, bool * result)
+// NOTE We can end up here even if we have no GUI, because we are called
+// by LyX::exec to handled command-line requests. So we may need to check
+// whether we have a GUI or not. The boolean use_gui holds this information.
+void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
{
+ // We'll set this back to false if need be.
bool dispatched = true;
switch (func.action) {
case LFUN_BUFFER_EXPORT: {
- bool const tmp = doExport(to_utf8(func.argument()), false);
- if (result)
- *result = tmp;
+ bool success = doExport(to_utf8(func.argument()), false);
+ dr.setError(success);
+ if (!success)
+ dr.setMessage(bformat(_("Error exporting to format: %1$s."),
+ func.argument()));
break;
}
break;
}
Branch * branch = branchList.find(branchName);
- if (!branch)
+ if (!branch) {
LYXERR0("Branch " << branchName << " does not exist.");
- else
+ dr.setError(true);
+ docstring const msg =
+ bformat(_("Branch \"%1$s\" does not exist."), branchName);
+ dr.setMessage(msg);
+ } else {
branch->setSelected(func.action == LFUN_BRANCH_ACTIVATE);
- if (result)
- *result = true;
+ dr.setError(false);
+ dr.update(Update::Force);
+ }
+ break;
+ }
+
+ case LFUN_BUFFER_PRINT: {
+ // we'll assume there's a problem until we succeed
+ dr.setError(true);
+ string target = func.getArg(0);
+ string target_name = func.getArg(1);
+ string command = func.getArg(2);
+
+ if (target.empty()
+ || target_name.empty()
+ || command.empty()) {
+ LYXERR0("Unable to parse " << func.argument());
+ docstring const msg =
+ bformat(_("Unable to parse \"%1$s\""), func.argument());
+ dr.setMessage(msg);
+ break;
+ }
+ if (target != "printer" && target != "file") {
+ LYXERR0("Unrecognized target \"" << target << '"');
+ docstring const msg =
+ bformat(_("Unrecognized target \"%1$s\""), from_utf8(target));
+ dr.setMessage(msg);
+ break;
+ }
+
+ if (!doExport("dvi", true)) {
+ showPrintError(absFileName());
+ dr.setMessage(_("Error exporting to DVI."));
+ break;
+ }
+
+ // Push directory path.
+ string const path = temppath();
+ // Prevent the compiler from optimizing away p
+ FileName pp(path);
+ PathChanger p(pp);
+
+ // there are three cases here:
+ // 1. we print to a file
+ // 2. we print directly to a printer
+ // 3. we print using a spool command (print to file first)
+ Systemcall one;
+ int res = 0;
+ string const dviname = changeExtension(latexName(true), "dvi");
+
+ if (target == "printer") {
+ if (!lyxrc.print_spool_command.empty()) {
+ // case 3: print using a spool
+ string const psname = changeExtension(dviname,".ps");
+ command += ' ' + lyxrc.print_to_file
+ + quoteName(psname)
+ + ' '
+ + quoteName(dviname);
+
+ string command2 = lyxrc.print_spool_command + ' ';
+ if (target_name != "default") {
+ command2 += lyxrc.print_spool_printerprefix
+ + target_name
+ + ' ';
+ }
+ command2 += quoteName(psname);
+ // First run dvips.
+ // If successful, then spool command
+ res = one.startscript(Systemcall::Wait, command);
+
+ if (res == 0) {
+ // If there's no GUI, we have to wait on this command. Otherwise,
+ // LyX deletes the temporary directory, and with it the spooled
+ // file, before it can be printed!!
+ Systemcall::Starttype stype = use_gui ?
+ Systemcall::DontWait : Systemcall::Wait;
+ res = one.startscript(stype, command2);
+ }
+ } else {
+ // case 2: print directly to a printer
+ if (target_name != "default")
+ command += ' ' + lyxrc.print_to_printer + target_name + ' ';
+ // as above....
+ Systemcall::Starttype stype = use_gui ?
+ Systemcall::DontWait : Systemcall::Wait;
+ res = one.startscript(stype, command + quoteName(dviname));
+ }
+
+ } else {
+ // case 1: print to a file
+ FileName const filename(makeAbsPath(target_name, filePath()));
+ FileName const dvifile(makeAbsPath(dviname, path));
+ if (filename.exists()) {
+ docstring text = bformat(
+ _("The file %1$s already exists.\n\n"
+ "Do you want to overwrite that file?"),
+ makeDisplayPath(filename.absFilename()));
+ if (Alert::prompt(_("Overwrite file?"),
+ text, 0, 1, _("&Overwrite"), _("&Cancel")) != 0)
+ break;
+ }
+ command += ' ' + lyxrc.print_to_file
+ + quoteName(filename.toFilesystemEncoding())
+ + ' '
+ + quoteName(dvifile.toFilesystemEncoding());
+ // as above....
+ Systemcall::Starttype stype = use_gui ?
+ Systemcall::DontWait : Systemcall::Wait;
+ res = one.startscript(stype, command);
+ }
+
+ if (res == 0)
+ dr.setError(false);
+ else {
+ dr.setMessage(_("Error running external commands."));
+ showPrintError(absFileName());
+ }
+ break;
}
default:
dispatched = false;
+ break;
}
- return dispatched;
+ dr.dispatched(dispatched);
}
{
OutputParams runparams(¶ms().encoding());
runparams.nice = true;
- runparams.flavor = OutputParams::LATEX;
+ runparams.flavor = params().useXetex ?
+ OutputParams::XETEX : OutputParams::LATEX;
runparams.linelen = lyxrc.plaintext_linelen;
// No side effect of file copying and image conversion
runparams.dryrun = true;
} // namespace anon
+FileName Buffer::getAutosaveFilename() const
+{
+ string const fpath = isUnnamed() ? lyxrc.document_path : filePath();
+ string const fname = "#" + d->filename.onlyFileName() + "#";
+ return makeAbsPath(fname, fpath);
+}
+
+
+void Buffer::removeAutosaveFile() const
+{
+ FileName const f = getAutosaveFilename();
+ if (f.exists())
+ f.removeFile();
+}
+
+
// Perfect target for a thread...
void Buffer::autoSave() const
{
// emit message signal.
message(_("Autosaving current document..."));
-
- // create autosave filename
- string fname = filePath();
- fname += '#';
- fname += d->filename.onlyFileName();
- fname += '#';
-
- AutoSaveBuffer autosave(*this, FileName(fname));
+ AutoSaveBuffer autosave(*this, getAutosaveFilename());
autosave.start();
markBakClean();
return "docbook";
if (isLiterate())
return "literate";
+ if (params().useXetex)
+ return "xetex";
if (params().encoding().package() == Encoding::japanese)
return "platex";
return "latex";
}
+string Buffer::getDefaultOutputFormat() const
+{
+ if (!params().defaultOutputFormat.empty()
+ && params().defaultOutputFormat != "default")
+ return params().defaultOutputFormat;
+ typedef vector<Format const *> Formats;
+ Formats formats = exportableFormats(true);
+ if (isDocBook()
+ || isLiterate()
+ || params().useXetex
+ || params().encoding().package() == Encoding::japanese) {
+ if (formats.empty())
+ return string();
+ // return the first we find
+ return formats.front()->name();
+ }
+ return lyxrc.default_view_format;
+}
+
+
+
bool Buffer::doExport(string const & format, bool put_in_tempdir,
string & result_file) const
{
bool inword = false;
bool ignoreword = false;
string lang_code;
+ // Go backward a bit if needed in order to return the word currently
+ // pointed by 'from'.
+ while (from && from.pos() && isLetter(from))
+ from.backwardPos();
+ // OK, we start from here.
to = from;
-
while (to.depth()) {
if (isLetter(to)) {
if (!inword) {
}
to.forwardPos();
}
-
+ from = to;
+ word.clear();
return false;
}
+
+int Buffer::spellCheck(DocIterator & from, DocIterator & to,
+ WordLangTuple & word_lang, docstring_list & suggestions) const
+{
+ int progress = 0;
+ SpellChecker::Result res = SpellChecker::OK;
+ SpellChecker * speller = theSpellChecker();
+ suggestions.clear();
+ docstring word;
+ while (nextWord(from, to, word)) {
+ ++progress;
+ string lang_code = lyxrc.spellchecker_use_alt_lang
+ ? lyxrc.spellchecker_alt_lang
+ : from.paragraph().getFontSettings(params(), from.pos()).language()->code();
+ WordLangTuple wl(word, lang_code);
+ res = speller->check(wl);
+ // ... just bail out if the spellchecker reports an error.
+ if (!speller->error().empty()) {
+ throw ExceptionMessage(WarningException,
+ _("The spellchecker has failed."), speller->error());
+ }
+ if (res != SpellChecker::OK && res != SpellChecker::IGNORED_WORD) {
+ word_lang = wl;
+ break;
+ }
+ from = to;
+ }
+ while (!(word = speller->nextMiss()).empty())
+ suggestions.push_back(word);
+ return progress;
+}
+
} // namespace lyx