#include "LaTeXFeatures.h"
#include "LaTeX.h"
#include "Layout.h"
-#include "Lexer.h"
#include "LyXAction.h"
#include "LyX.h"
#include "LyXRC.h"
#include "support/filetools.h"
#include "support/gettext.h"
#include "support/gzstream.h"
+#include "support/Lexer.h"
#include "support/lstrings.h"
#include "support/mutex.h"
#include "support/os.h"
}
+Undo const & Buffer::undo() const
+{
+ return d->undo_;
+}
+
+
void Buffer::setChild(DocIterator const & dit, Buffer * child)
{
d->children_positions[child] = dit;
params().clearRemovedModules();
params().clearIncludedChildren();
params().pdfoptions().clear();
+ params().document_metadata.clear();
params().indiceslist().clear();
params().backgroundcolor = lyx::rgbFromHexName("#ffffff");
params().isbackgroundcolor = false;
params().biblatex_citestyle.erase();
params().multibib.erase();
params().lineno_opts.clear();
+ params().spellignore().clear();
for (int i = 0; i < 4; ++i) {
params().user_defined_bullet(i) = ITEMIZE_DEFAULTS[i];
}
+bool Buffer::isSyncTeXenabled() const
+{
+ bool enabled = params().output_sync;
+
+ if (!enabled)
+ for (auto const & c : theConverters()) {
+ const string dest = c.to().substr(0,3);
+ if (dest == "dvi" || dest == "pdf") {
+ const string cmd = c.command();
+ enabled |= cmd.find("-synctex=") != string::npos
+ && cmd.find("-synctex=0") == string::npos;
+ if (enabled)
+ break;
+ }
+ }
+ return enabled;
+}
+
bool Buffer::importString(string const & format, docstring const & contents, ErrorList & errorList)
{
Format const * fmt = theFormats().getFormat(format);
FileName const lyx = tempFileName("Buffer_importFileXXXXXX.lyx");
Converters::RetVal const retval =
- theConverters().convert(nullptr, name, lyx, name, format, "lyx", errorList);
+ theConverters().convert(this, name, lyx, name, format, "lyx", errorList);
if (retval == Converters::SUCCESS) {
bool const success = readFile(lyx) == ReadSuccess;
removeTempFile(lyx);
OutputParams runparams = runparams_in;
string const encoding = runparams.encoding->iconvName();
- LYXERR(Debug::LATEX, "makeLaTeXFile encoding: " << encoding << ", fname=" << fname.realPath());
+ LYXERR(Debug::OUTFILE, "makeLaTeXFile encoding: " << encoding << ", fname=" << fname.realPath());
ofdocstream ofs;
try { ofs.reset(encoding); }
lyx_exit(1);
}
- d->texrow = move(os.texrow());
+ d->texrow = std::move(os.texrow());
ofs.close();
if (ofs.fail()) {
BufferEncodings::initUnicodeMath(*this);
// validate the buffer.
- LYXERR(Debug::LATEX, " Validating buffer...");
+ LYXERR(Debug::OUTFILE, " Validating buffer...");
LaTeXFeatures features(*this, params(), runparams);
validate(features);
// This is only set once per document (in master)
if (!runparams.is_child) {
runparams.use_polyglossia = features.usePolyglossia();
- runparams.use_hyperref = features.isRequired("hyperref");
+ runparams.use_hyperref = features.isRequired("hyperref")
+ || features.isProvided("hyperref");
runparams.use_CJK = features.mustProvide("CJK");
}
- LYXERR(Debug::LATEX, " Buffer validation done.");
+ LYXERR(Debug::OUTFILE, " Buffer validation done.");
bool const output_preamble =
output == FullSource || output == OnlyPreamble;
docdir = subst(docdir, "~", "\\string~");
bool const nonascii = !isAscii(from_utf8(docdir));
// LaTeX 2019/10/01 handles non-ascii path without detokenize
- bool const utfpathlatex = features.isAvailable("LaTeX-2019/10/01");
+ bool const utfpathlatex = features.isAvailableAtLeastFrom("LaTeX", 2019, 10);
bool const detokenize = !utfpathlatex && nonascii;
bool const quote = contains(docdir, ' ');
if (utfpathlatex && nonascii)
if (output_preamble) {
os << "\\end{document}\n";
- LYXERR(Debug::LATEX, "makeLaTeXFile...done");
+ LYXERR(Debug::OUTFILE, "makeLaTeXFile...done");
} else {
- LYXERR(Debug::LATEX, "LaTeXFile for inclusion made.");
+ LYXERR(Debug::OUTFILE, "LaTeXFile for inclusion made.");
}
runparams_in.encoding = runparams.encoding;
OutputParams const & runparams,
OutputWhat output) const
{
- LYXERR(Debug::LATEX, "makeDocBookFile...");
+ LYXERR(Debug::OUTFILE, "makeDocBookFile...");
ofdocstream ofs;
if (!openFileWrite(ofs, fname))
updateBuffer();
updateMacroInstances(OutputUpdate);
- ExportStatus const retval =
- writeDocBookSource(ofs, runparams, output);
+ ExportStatus const retval = writeDocBookSource(ofs, runparams, output);
if (retval == ExportKilled)
return ExportKilled;
bool const output_preamble =
output == FullSource || output == OnlyPreamble;
bool const output_body =
- output == FullSource || output == OnlyBody || output == IncludedFile;
+ output == FullSource || output == OnlyBody || output == IncludedFile;
if (output_preamble) {
// XML preamble, no doctype needed.
<< "<!-- This DocBook file was created by LyX " << lyx_version
<< "\n See https://www.lyx.org/ for more information -->\n";
+ // Prepare the name space declaration for MathML depending on document preferences.
+ string mathmlNamespace;
+ if (params().docbook_mathml_prefix != BufferParams::NoPrefix) {
+ string mathmlPrefix;
+ if (params().docbook_mathml_prefix == BufferParams::MPrefix)
+ mathmlPrefix = "m";
+ else if (params().docbook_mathml_prefix == BufferParams::MMLPrefix)
+ mathmlPrefix = "mml";
+ mathmlNamespace = + " xmlns:" + mathmlPrefix + "=\"http://www.w3.org/1998/Math/MathML\"";
+ }
+
+ // XML-compatible language code: in lib/languages, language codes are
+ // given as dictionary file names; HTML5 expects to follow BCP47. This
+ // function implements a simple heuristic that does the conversion.
+ std::string htmlCode = params().language->code();
+ std::replace(htmlCode.begin(), htmlCode.end(), '_', '-');
+
// Directly output the root tag, based on the current type of document.
- string languageCode = params().language->code();
- string params = "xml:lang=\"" + languageCode + '"'
- + " xmlns=\"http://docbook.org/ns/docbook\""
- + " xmlns:xlink=\"http://www.w3.org/1999/xlink\""
- + " xmlns:m=\"http://www.w3.org/1998/Math/MathML\""
- + " xmlns:xi=\"http://www.w3.org/2001/XInclude\""
- + " version=\"5.2\"";
+ string attributes = "xml:lang=\"" + htmlCode + '"'
+ + " xmlns=\"http://docbook.org/ns/docbook\""
+ + " xmlns:xlink=\"http://www.w3.org/1999/xlink\""
+ + mathmlNamespace
+ + " xmlns:xi=\"http://www.w3.org/2001/XInclude\""
+ + " version=\"5.2\"";
+ // Version 5.2 is required for formalgroup.
- os << "<" << from_ascii(tclass.docbookroot()) << " " << from_ascii(params) << ">\n";
+ os << "<" << from_ascii(tclass.docbookroot()) << " " << from_ascii(attributes) << ">\n";
}
if (output_body) {
Buffer::ExportStatus Buffer::makeLyXHTMLFile(FileName const & fname,
OutputParams const & runparams) const
{
- LYXERR(Debug::LATEX, "makeLyXHTMLFile...");
+ LYXERR(Debug::OUTFILE, "makeLyXHTMLFile...");
ofdocstream ofs;
if (!openFileWrite(ofs, fname))
output == FullSource || output == OnlyBody || output == IncludedFile;
if (output_preamble) {
- os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN\" \"http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd\">\n"
- // FIXME Language should be set properly.
- << "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
+ // HTML5-compatible language code: in lib/languages, language codes are
+ // given as dictionary file names; HTML5 expects to follow BCP47. This
+ // function implements a simple heuristic that does the conversion.
+ std::string htmlCode = params().language->code();
+ std::replace(htmlCode.begin(), htmlCode.end(), '_', '-');
+
+ os << "<!DOCTYPE html>\n"
+ << "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"" << from_ascii(htmlCode) << "\">\n"
<< "<head>\n"
- << "<meta name=\"GENERATOR\" content=\"" << PACKAGE_STRING << "\" />\n"
- // FIXME Presumably need to set this right
- << "<meta http-equiv=\"Content-type\" content=\"text/html;charset=UTF-8\" />\n";
+ << "<meta name=\"generator\" content=\"" << PACKAGE_STRING << "\" />\n";
docstring const & doctitle = features.htmlTitle();
os << "<title>"
// we are here if the CSS is supposed to be written to the header
// or if we failed to write it to an external file.
if (!written) {
- os << "<style type='text/css'>\n"
+ os << "<style>\n"
<< dstyles
<< "\n</style>\n";
}
for (Paragraph const & p : paragraphs())
p.validate(features);
- if (lyxerr.debugging(Debug::LATEX)) {
+ if (lyxerr.debugging(Debug::OUTFILE)) {
features.showStruct();
}
}
-void Buffer::getLabelList(vector<docstring> & list) const
+void Buffer::getLabelList(vector<std::tuple<docstring, docstring, docstring>> & list) const
{
// If this is a child document, use the master's list instead.
if (parent()) {
list.clear();
shared_ptr<Toc> toc = d->toc_backend.toc("label");
for (auto const & tocit : *toc) {
- if (tocit.depth() == 0)
- list.push_back(tocit.str());
+ if (tocit.depth() == 0) {
+ list.push_back(make_tuple(tocit.str(), tocit.asString(), tocit.prettyStr()));
+ }
}
}
{
d->bibinfo_cache_valid_ = false;
d->cite_labels_valid_ = false;
- removeBiblioTempFiles();
+ scheduleBiblioTempRemoval();
// also invalidate the cache for the parent buffer
Buffer const * const pbuf = d->parent();
if (pbuf)
Buffer const * const pbuf = parent();
if (pbuf)
pbuf->removeBiblioTempFiles();
+ removeBiblioTemps = false;
}
}
-bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag)
+bool Buffer::branchActivationEnabled(FuncCode act, docstring const & branch) const
+{
+ bool const master = act == LFUN_BRANCH_MASTER_ACTIVATE
+ || act == LFUN_BRANCH_MASTER_DEACTIVATE;
+ bool const activate = act == LFUN_BRANCH_ACTIVATE
+ || act == LFUN_BRANCH_MASTER_ACTIVATE;
+ Buffer const * buf = master ? masterBuffer() : this;
+ Branch const * our_branch = buf->params().branchlist().find(branch);
+ // Can be disabled if
+ // - this is a _MASTER_ command and there is no master
+ // - the relevant buffer does not know the branch
+ // - the branch is already in the desired state
+ return ((!master || parent() != nullptr)
+ && !branch.empty() && our_branch
+ && our_branch->isSelected() != activate);
+}
+
+
+bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag) const
{
if (isInternal()) {
// FIXME? if there is an Buffer LFUN that can be dispatched even
case LFUN_BRANCH_ACTIVATE:
case LFUN_BRANCH_DEACTIVATE:
case LFUN_BRANCH_MASTER_ACTIVATE:
- case LFUN_BRANCH_MASTER_DEACTIVATE: {
- bool const master = (cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE
- || cmd.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
- BranchList const & branchList = master ? masterBuffer()->params().branchlist()
- : params().branchlist();
- docstring const & branchName = cmd.argument();
- flag.setEnabled(!branchName.empty() && branchList.find(branchName));
+ case LFUN_BRANCH_MASTER_DEACTIVATE:
+ // Let a branch inset handle that
+ if (cmd.argument().empty())
+ return false;
+ flag.setEnabled(branchActivationEnabled(cmd.action(), cmd.argument()));
break;
- }
case LFUN_BRANCH_ADD:
case LFUN_BRANCHES_RENAME:
}
+bool Buffer::branchActivationDispatch(FuncCode act, docstring const & branch)
+{
+ bool const master = (act == LFUN_BRANCH_MASTER_ACTIVATE
+ || act == LFUN_BRANCH_MASTER_DEACTIVATE);
+ bool const activate = (act == LFUN_BRANCH_ACTIVATE
+ || act == LFUN_BRANCH_MASTER_ACTIVATE);
+ Buffer * buf = master ? const_cast<Buffer *>(masterBuffer()) : this;
+ Branch * our_branch = buf->params().branchlist().find(branch);
+
+ // See comment in branchActivationStatus
+ if ((master && parent() == nullptr)
+ || !our_branch
+ || our_branch->isSelected() == activate)
+ return false;
+
+ if (master && !buf->hasGuiDelegate()
+ && (!theApp() || !theApp()->unhide(buf)))
+ // at least issue a warning for now (ugly, but better than dataloss).
+ frontend::Alert::warning(_("Branch state changes in master document"),
+ lyx::support::bformat(_("The state of the branch '%1$s' "
+ "was changed in the master file. "
+ "Please make sure to save the master."), branch), true);
+
+ UndoGroupHelper ugh(buf);
+ buf->undo().recordUndoBufferParams(CursorData());
+ our_branch->setSelected(activate);
+ // cur.forceBufferUpdate() is not enough)
+ buf->updateBuffer();
+
+ // if branch exists in a descendant, update previews.
+ // TODO: only needed if "Show preview" is enabled in the included inset.
+ bool exists_in_desc = false;
+ for (auto const & it : buf->getDescendants()) {
+ if (it->params().branchlist().find(branch))
+ exists_in_desc = true;
+ }
+ if (exists_in_desc) {
+ // TODO: ideally we would only update the previews of the
+ // specific children that have this branch directly or
+ // in one of their descendants
+ buf->removePreviews();
+ buf->updatePreviews();
+ }
+ return true;
+}
+
+
void Buffer::dispatch(string const & command, DispatchResult & result)
{
return dispatch(lyxaction.lookupFunc(command), result);
// whether we have a GUI or not. The boolean use_gui holds this information.
void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
{
+ LYXERR(Debug::ACTION, "Buffer::dispatch: cmd: " << func);
if (isInternal()) {
// FIXME? if there is an Buffer LFUN that can be dispatched even
// if internal, put a switch '(cmd.action())' here.
case LFUN_BRANCH_DEACTIVATE:
case LFUN_BRANCH_MASTER_ACTIVATE:
case LFUN_BRANCH_MASTER_DEACTIVATE: {
- bool const master = (func.action() == LFUN_BRANCH_MASTER_ACTIVATE
- || func.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
- Buffer * buf = master ? const_cast<Buffer *>(masterBuffer())
- : this;
-
- docstring const & branch_name = func.argument();
- // the case without a branch name is handled elsewhere
- if (branch_name.empty()) {
- dispatched = false;
- break;
- }
- Branch * branch = buf->params().branchlist().find(branch_name);
- if (!branch) {
- LYXERR0("Branch " << branch_name << " does not exist.");
- dr.setError(true);
- docstring const msg =
- bformat(_("Branch \"%1$s\" does not exist."), branch_name);
- dr.setMessage(msg);
- break;
+ // Let a branch inset handle that
+ if (func.argument().empty()) {
+ dr.dispatched(false);
+ return;
}
- bool const activate = (func.action() == LFUN_BRANCH_ACTIVATE
- || func.action() == LFUN_BRANCH_MASTER_ACTIVATE);
- if (branch->isSelected() != activate) {
- buf->undo().recordUndoBufferParams(CursorData());
- branch->setSelected(activate);
- dr.setError(false);
+ bool const res = branchActivationDispatch(func.action(), func.argument());
+ dr.setError(!res);
+ if (res)
dr.screenUpdate(Update::Force);
- dr.forceBufferUpdate();
- }
break;
}
// loop over children
for (auto const & p : d->children_positions) {
Buffer * child = const_cast<Buffer *>(p.first);
- // This can happen when called during GUI operations
- if (!theBufferList().isLoaded(child))
- continue;
// No duplicates
ListOfBuffers::const_iterator bit = find(children.begin(), children.end(), child);
if (bit != children.end())
// FIXME (Abdel), I don't understand why we pass 'it' here
// instead of 'macroTemplate' defined above... is this correct?
macros[macroTemplate.name()][it] =
- Impl::ScopeMacro(scope, MacroData(const_cast<Buffer *>(owner_), it));
+ Impl::ScopeMacro(scope, MacroData(owner_, it));
}
// next paragraph
LaTeXFeatures features(*this, params(), runparams);
validate(features);
runparams.use_polyglossia = features.usePolyglossia();
- runparams.use_hyperref = features.isRequired("hyperref");
+ runparams.use_babel = features.useBabel();
+ runparams.use_hyperref = features.isRequired("hyperref")
+ || features.isProvided("hyperref");
// latex or literate
otexstream ots(os);
// output above
}
+void Buffer::scheduleRedrawWorkAreas() const
+{
+ if (d->wa_)
+ d->wa_->scheduleRedraw();
+}
+
+
void Buffer::resetAutosaveTimers() const
{
if (d->gui_)
void Buffer::setMathFlavor(OutputParams & op) const
{
+ // Passes the way to generate formulae to the XHTML output code.
+ // In particular, this function has no impact on the DocBook code, as it
+ // uses another mechanism to handle math flavours.
switch (params().html_math_output) {
case BufferParams::MathML:
op.math_flavor = OutputParams::MathAsMathML;
Buffer::ExportStatus Buffer::doExport(string const & target, bool put_in_tempdir,
bool includeall, string & result_file) const
{
+ if (removeBiblioTemps)
+ removeBiblioTempFiles();
LYXERR(Debug::FILES, "target=" << target);
OutputParams runparams(¶ms().encoding());
string format = target;
Converters converters = theConverters();
bool need_nice_file = false;
if (find(backs.begin(), backs.end(), format) == backs.end()) {
- // Get shortest path to format
+ // Get the shortest path to format
converters.buildGraph();
Graph::EdgePath path;
for (string const & sit : backs) {
translateIfPossible(theFormats().prettyName(format)));
if (format == "pdf4")
s += "\n"
- + bformat(_("Hint: use non-TeX fonts or set input encoding "
+ + bformat(_("Hint: use non-TeX fonts or set input encoding"
" to '%1$s'"), from_utf8(encodings.fromLyXName("ascii")->guiName()));
Alert::error(_("Couldn't export file"), s);
}
result_file = changeExtension(d->exportFileName().absFileName(), ext);
else
result_file = dest_filename;
- // We need to copy referenced files (e. g. included graphics
+ // We need to copy referenced files (e.g. included graphics
// if format == "dvi") to the result dir.
vector<ExportedFile> const extfiles =
runparams.exportdata->externalFiles(format);
"%1$s exists.\n\nRecover emergency save?"), file);
int const load_emerg = Alert::prompt(_("Load emergency save?"), text,
- 0, 2, _("&Recover"), _("&Load Original"), _("&Cancel"));
+ 0, 3, _("&Recover"), _("&Load Original"), _("&Only show difference"), _("&Cancel"));
switch (load_emerg)
{
"asked about it again the next time you try to load "
"this file, and may over-write your own work."));
} else {
- Alert::warning(_("Emergency File Renames"),
+ Alert::warning(_("Emergency File Renamed"),
bformat(_("Emergency file renamed as:\n %1$s"),
from_utf8(newname.onlyFileName())));
}
return ReadOriginal;
}
+ case 2: {
+ string const f1 = d->filename.absFileName();
+ string const f2 = emergencyFile.absFileName();
+ if (loadThisLyXFile(d->filename) != ReadSuccess)
+ return ReadCancel;
+ string const par = "compare run-blocking " + quoteName(f1) + " " + quoteName(f2);
+ LYXERR(Debug::FILES, par << "\n");
+ lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, par));
+
+ //release the emergency buffer loaded by compare
+ Buffer * emerBuffer = theBufferList().getBuffer(emergencyFile);
+ if (emerBuffer)
+ theBufferList().release(emerBuffer);
+
+ return ReadCancel; //Release the buffer of Original immediatelly
+ }
default:
break;
}
}
+void Buffer::updateBuffer() const
+{
+ updateBuffer(UpdateMaster, InternalUpdate);
+ d->need_update = false;
+}
+
+
void Buffer::updateBuffer(UpdateScope scope, UpdateType utype) const
{
LBUFERR(!text().paragraphs().empty());
+ // This can be called when loading a file, so that there be no
+ // open undo group.
+ UndoGroupHelper ugh(const_cast<Buffer *>(this));
+
// Use the master text class also for child documents
Buffer const * const master = masterBuffer();
DocumentClass const & textclass = master->params().documentClass();
par.itemdepth = getItemDepth(it);
if (layout.margintype == MARGIN_MANUAL) {
- if (par.params().labelWidthString().empty())
- par.params().labelWidthString(par.expandLabel(layout, bp));
+ // nothing to do: empty label width string is fine.
} else if (layout.latextype == LATEX_BIB_ENVIRONMENT) {
// we do not need to do anything here, since the empty case is
// handled during export.
switch(layout.labeltype) {
case LABEL_ITEMIZE: {
- // At some point of time we should do something more
- // clever here, like:
- // par.params().labelString(
- // bp.user_defined_bullet(par.itemdepth).getText());
- // for now, use a simple hardcoded label
- docstring itemlabel;
- switch (par.itemdepth) {
- case 0:
- // • U+2022 BULLET
- itemlabel = char_type(0x2022);
- break;
- case 1:
- // – U+2013 EN DASH
- itemlabel = char_type(0x2013);
- break;
- case 2:
- // ∗ U+2217 ASTERISK OPERATOR
- itemlabel = char_type(0x2217);
- break;
- case 3:
- // · U+00B7 MIDDLE DOT
- itemlabel = char_type(0x00b7);
- break;
- }
- par.params().labelString(itemlabel);
+ par.params().labelString(
+ (par.itemdepth < 4)
+ ? bp.user_defined_bullet(par.itemdepth).getLabel()
+ // Display fallback for too deeply nested items
+ : bformat(from_ascii("[?%1$d]"), int(par.itemdepth + 1)));
break;
}
void Buffer::updateBuffer(ParIterator & parit, UpdateType utype, bool const deleted) const
{
+ // if fomatted references are shown in workarea update buffer accordingly
+ if (params().use_formatted_ref)
+ utype = OutputUpdate;
+
pushIncludedBuffer(this);
// LASSERT: Is it safe to continue here, or should we just return?
LASSERT(parit.pit() == 0, /**/);
}
+void Buffer::requestSpellcheck()
+{
+ ParagraphList::iterator pit = paragraphs().begin();
+ ParagraphList::iterator pend = paragraphs().end();
+ for (; pit != pend; ++pit)
+ pit->requestSpellCheck();
+}
+
+
void Buffer::Impl::updateStatistics(DocIterator & from, DocIterator & to, bool skipNoOutput)
{
bool inword = false;
docstring const disp_fn = makeDisplayPath(d->filename.absFileName());
// clear parent. this will get reset if need be.
+ Buffer const * oldparent = d->parent();
d->setParent(nullptr);
ReadStatus const status = loadLyXFile();
+ // The inset members in cursors held by buffer views are now wrong.
+ workAreaManager().sanitizeCursors();
+ setBusy(false);
if (status == ReadSuccess) {
updateBuffer();
changed(true);
updateTitles();
+ // reset parent if this hasn't been done yet
+ // but only if this is still its child (e.g.,
+ // not after the former child has been saved as...)
+ if (!d->parent() && oldparent && oldparent->isFullyLoaded()
+ && oldparent->isChild(this))
+ d->setParent(oldparent);
markClean();
message(bformat(_("Document %1$s reloaded."), disp_fn));
d->undo_.clear();
} else {
message(bformat(_("Could not reload document %1$s."), disp_fn));
}
- setBusy(false);
removePreviews();
updatePreviews();
errors("Parse");
"checksum unchanged: " << filename);
return;
}
+ lyx_clean = false;
// If the file has been deleted, only mark the file as dirty since it is
// pointless to prompt for reloading. If later a file is moved into this
// location, then the externally modified warning will appear then.
if (exists)
- externally_modified_ = true;
+ externally_modified_ = true;
// Update external modification notification.
// Dirty buffers must be visible at all times.
- if (wa_ && wa_->unhide(owner_))
+ if (wa_ && wa_->unhide(owner_)) {
wa_->updateTitles();
+ if (!exists) {
+ frontend::Alert::warning(
+ _("File deleted from disk"),
+ bformat(_("The file\n %1$s\n"
+ "has been deleted from disk!"),
+ from_utf8(filename.absFileName())));
+ }
+ }
else
// Unable to unhide the buffer (e.g. no GUI or not current View)
lyx_clean = true;