#include "graphics/GraphicsCache.h"
#include "graphics/PreviewLoader.h"
+#include "frontends/Application.h"
#include "frontends/alert.h"
#include "frontends/Delegates.h"
#include "frontends/WorkAreaManager.h"
bool active;
};
-typedef vector<LabelInfo> RefCache;
+typedef vector<LabelInfo> LabelCache;
+
+typedef map<docstring, Buffer::References> RefCache;
} // namespace
/// we ran updateBuffer(), i.e., whether citation labels may need
/// to be updated.
mutable bool cite_labels_valid_;
+ /// Do we have a bibliography environment?
+ mutable bool have_bibitems_;
/// These two hold the file name and format, written to by
/// Buffer::preview and read from by LFUN_BUFFER_VIEW_CACHE.
/// If there was an error when previewing, on the next preview we do
/// a fresh compile (e.g. in case the user installed a package that
/// was missing).
- bool preview_error_;
+ bool require_fresh_start_;
- /// Cache the insets, their associated refs (with positions),
- /// and whether the insets are active.
+ /// Cache the references associated to a label and their positions
+ /// in the buffer.
mutable RefCache ref_cache_;
+ /// Cache the label insets and their activity status.
+ mutable LabelCache label_cache_;
/// our Text that should be wrapped in an InsetText
InsetText * inset;
+ (with_blanks ? blank_count_ : 0);
}
- // does the buffer contain tracked changes? (if so, we automatically
- // display the review toolbar, for instance)
- mutable bool tracked_changes_present_;
-
// Make sure the file monitor monitors the good file.
void refreshFileMonitor();
/// has been externally modified? Can be reset by the user.
mutable bool externally_modified_;
+ ///Binding LaTeX lines with buffer positions.
+ //Common routine for LaTeX and Reference errors listing.
+ void traverseErrors(TeXErrors::Errors::const_iterator err,
+ TeXErrors::Errors::const_iterator end,
+ ErrorList & errorList) const;
+
private:
/// So we can force access via the accessors.
mutable Buffer const * parent_buffer;
file_fully_loaded(false), file_format(LYX_FORMAT), need_format_backup(false),
ignore_parent(false), toc_backend(owner), macro_lock(false),
checksum_(0), wa_(0), gui_(0), undo_(*owner), bibinfo_cache_valid_(false),
- cite_labels_valid_(false), preview_error_(false),
+ cite_labels_valid_(false), have_bibitems_(false), require_fresh_start_(false),
inset(0), preview_loader_(0), cloned_buffer_(cloned_buffer),
clone_list_(0), doing_export(false),
- tracked_changes_present_(0), externally_modified_(false), parent_buffer(0),
+ externally_modified_(false), parent_buffer(0),
word_count_(0), char_count_(0), blank_count_(0)
{
refreshFileMonitor();
if (!cloned_buffer_) {
temppath = createBufferTmpDir();
lyxvc.setBuffer(owner_);
+ Language const * inplang = theApp() ?
+ languages.getFromCode(theApp()->inputLanguageCode())
+ : nullptr;
+ if (inplang)
+ params.language = inplang;
if (use_gui)
wa_ = new frontend::WorkAreaManager;
return;
bibinfo_cache_valid_ = cloned_buffer_->d->bibinfo_cache_valid_;
bibfile_status_ = cloned_buffer_->d->bibfile_status_;
cite_labels_valid_ = cloned_buffer_->d->cite_labels_valid_;
+ have_bibitems_ = cloned_buffer_->d->have_bibitems_;
unnamed = cloned_buffer_->d->unnamed;
internal_buffer = cloned_buffer_->d->internal_buffer;
layout_position = cloned_buffer_->d->layout_position;
preview_file_ = cloned_buffer_->d->preview_file_;
preview_format_ = cloned_buffer_->d->preview_format_;
- preview_error_ = cloned_buffer_->d->preview_error_;
- tracked_changes_present_ = cloned_buffer_->d->tracked_changes_present_;
+ require_fresh_start_ = cloned_buffer_->d->require_fresh_start_;
}
if (branch_suffix.empty())
return filename;
- string const name = filename.onlyFileNameWithoutExt()
- + to_utf8(branch_suffix);
+ string const name = addExtension(filename.onlyFileNameWithoutExt()
+ + to_utf8(branch_suffix), filename.extension());
FileName res(filename.onlyPath().absFileName() + "/" + name);
- res.changeExtension(filename.extension());
return res;
}
params().headsep.erase();
params().footskip.erase();
params().columnsep.erase();
+ params().font_roman_opts.erase();
+ params().font_sans_opts.erase();
+ params().font_typewriter_opts.erase();
params().fonts_cjk.erase();
params().listings_params.clear();
params().clearLayoutModules();
params().biblatex_bibstyle.erase();
params().biblatex_citestyle.erase();
params().multibib.erase();
+ params().lineno_opts.clear();
for (int i = 0; i < 4; ++i) {
params().user_defined_bullet(i) = ITEMIZE_DEFAULTS[i];
}
-bool Buffer::lastPreviewError() const
+bool Buffer::freshStartRequired() const
{
- return d->preview_error_;
+ return d->require_fresh_start_;
+}
+
+void Buffer::requireFreshStart(bool const b) const
+{
+ d->require_fresh_start_ = b;
}
{
OutputParams runparams = runparams_in;
- // XeTeX with TeX fonts is only safe with ASCII encoding (see also #9740),
- // Check here, because the "flavor" is not known in BufferParams::encoding()
- // (power users can override this safety measure selecting "utf8-plain").
- if (!params().useNonTeXFonts && (runparams.flavor == OutputParams::XETEX)
- && (runparams.encoding->name() != "utf8-plain"))
- runparams.encoding = encodings.fromLyXName("ascii");
-
string const encoding = runparams.encoding->iconvName();
LYXERR(Debug::LATEX, "makeLaTeXFile encoding: " << encoding << ", fname=" << fname.realPath());
try { ofs.reset(encoding); }
catch (iconv_codecvt_facet_exception const & e) {
lyxerr << "Caught iconv exception: " << e.what() << endl;
- Alert::error(_("Iconv software exception Detected"), bformat(_("Please "
- "verify that the support software for your encoding (%1$s) is "
- "properly installed"), from_ascii(encoding)));
+ Alert::error(_("Iconv software exception Detected"),
+ bformat(_("Please verify that the `iconv' support software is"
+ " properly installed and supports the selected encoding"
+ " (%1$s), or change the encoding in"
+ " Document>Settings>Language."), from_ascii(encoding)));
return ExportError;
}
if (!openFileWrite(ofs, fname))
OutputParams runparams = runparams_in;
- // XeTeX with TeX fonts is only safe with ASCII encoding,
- // Check here, because the "flavor" is not known in BufferParams::encoding()
- // (power users can override this safety measure selecting "utf8-plain").
- if (!params().useNonTeXFonts && (runparams.flavor == OutputParams::XETEX)
- && (runparams.encoding->name() != "utf8-plain"))
- runparams.encoding = encodings.fromLyXName("ascii");
- // FIXME: when only the current paragraph is shown, this is ignored
- // (or not reached) and characters encodable in the current
- // encoding are not converted to ASCII-representation.
-
// Some macros rely on font encoding
runparams.main_fontenc = params().main_font_encoding();
LaTeXFeatures features(*this, params(), runparams);
validate(features);
// This is only set once per document (in master)
- if (!runparams.is_child)
+ if (!runparams.is_child) {
runparams.use_polyglossia = features.usePolyglossia();
+ runparams.use_CJK = features.mustProvide("CJK");
+ }
LYXERR(Debug::LATEX, " Buffer validation done.");
bool const output_preamble =
os << "\\catcode`\\%=11"
"\\def\\%{%}\\catcode`\\%=14\n";
}
- bool const detokenize = !isAscii(from_utf8(docdir));
+ if (contains(docdir, '~'))
+ 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 detokenize = !utfpathlatex && nonascii;
bool const quote = contains(docdir, ' ');
+ if (utfpathlatex && nonascii)
+ os << "\\UseRawInputEncoding\n";
os << "\\makeatletter\n"
<< "\\def\\input@path{{";
if (detokenize)
runparams.use_babel = params().writeLaTeX(os, features,
d->filename.onlyPath());
+ // Active characters
+ runparams.active_chars = features.getActiveChars();
+
// Biblatex bibliographies are loaded here
if (params().useBiblatex()) {
- vector<docstring> const bibfiles =
+ vector<pair<docstring, string>> const bibfiles =
prepareBibFilePaths(runparams, getBibfiles(), true);
- for (docstring const & file: bibfiles)
- os << "\\addbibresource{" << file << "}\n";
+ for (pair<docstring, string> const & file: bibfiles) {
+ os << "\\addbibresource";
+ if (!file.second.empty())
+ os << "[bibencoding=" << file.second << "]";
+ os << "{" << file.first << "}\n";
+ }
}
if (!runparams.dryrun && features.hasPolyglossiaExclusiveLanguages()
map<docstring, FileName>::const_iterator it =
bibfileCache.find(bibid);
if (it != bibfileCache.end()) {
- // i.e., bibfileCache[bibid]
+ // i.e., return bibfileCache[bibid];
return it->second;
}
LYXERR(Debug::FILES, "Reading file location for " << bibid);
- string texfile = changeExtension(to_utf8(bibid), "bib");
- // note that, if the filename can be found directly from the path,
- // findtexfile will just return a FileName object for that path.
- FileName file(findtexfile(texfile, "bib"));
- if (file.empty())
- file = FileName(makeAbsPath(texfile, filePath()));
+ string const texfile = changeExtension(to_utf8(bibid), "bib");
+ // we need to check first if this file exists where it's said to be.
+ // there's a weird bug that occurs otherwise: if the file is in the
+ // Buffer's directory but has the same name as some file that would be
+ // found by kpsewhich, then we find the latter, not the former.
+ FileName const local_file = makeAbsPath(texfile, filePath());
+ FileName file = local_file;
+ if (!file.exists()) {
+ // there's no need now to check whether the file can be found
+ // locally
+ file = findtexfile(texfile, "bib", true);
+ if (file.empty())
+ file = local_file;
+ }
LYXERR(Debug::FILES, "Found at: " << file);
bibfileCache[bibid] = file;
return;
}
- // if we already know the cache is invalid, no need to check
- // the timestamps
+ // If we already know the cache is invalid, stop here.
+ // This is important in the case when the bibliography
+ // environment (rather than Bib[la]TeX) is used.
+ // In that case, the timestamp check below gives no
+ // sensible result. Rather than that, the cache will
+ // be invalidated explicitly via invalidateBibInfoCache()
+ // by the Bibitem inset.
+ // Same applies for bib encoding changes, which trigger
+ // invalidateBibInfoCache() by InsetBibtex.
if (!d->bibinfo_cache_valid_)
return;
- // we'll assume it's ok and change this if it's not
+ if (d->have_bibitems_) {
+ // We have a bibliography environment.
+ // Invalidate the bibinfo cache unconditionally.
+ // Cite labels will get invalidated by the inset if needed.
+ d->bibinfo_cache_valid_ = false;
+ return;
+ }
+
+ // OK. This is with Bib(la)tex. We'll assume the cache
+ // is valid and change this if we find changes in the bibs.
d->bibinfo_cache_valid_ = true;
d->cite_labels_valid_ = true;
clearBibFileCache();
d->bibinfo_.clear();
FileNameList checkedFiles;
+ d->have_bibitems_ = false;
collectBibKeys(checkedFiles);
d->bibinfo_cache_valid_ = true;
}
void Buffer::collectBibKeys(FileNameList & checkedFiles) const
{
- for (InsetIterator it = inset_iterator_begin(inset()); it; ++it)
+ for (InsetIterator it = inset_iterator_begin(inset()); it; ++it) {
it->collectBibKeys(it, checkedFiles);
+ if (it->lyxCode() == BIBITEM_CODE) {
+ if (parent() != 0)
+ parent()->d->have_bibitems_ = true;
+ else
+ d->have_bibitems_ = true;
+ }
+ }
}
if (params().save_transient_properties)
undo().recordUndoBufferParams(CursorData());
params().track_changes = !params().track_changes;
- if (!params().track_changes)
- dr.forceChangesUpdate();
break;
case LFUN_CHANGES_OUTPUT:
for (ParConstIterator it = par_iterator_begin(); it != end; ++it)
it->getLanguages(langs);
// also children
- ListOfBuffers clist = getDescendents();
+ ListOfBuffers clist = getDescendants();
for (auto const & cit : clist)
cit->getLanguages(langs);
}
}
-vector<docstring> const Buffer::prepareBibFilePaths(OutputParams const & runparams,
+vector<pair<docstring, string>> const Buffer::prepareBibFilePaths(OutputParams const & runparams,
docstring_list const & bibfilelist,
bool const add_extension) const
{
// Otherwise, store the (maybe absolute) path to the original,
// unmangled database name.
- vector<docstring> res;
+ vector<pair<docstring, string>> res;
// determine the export format
string const tex_format = flavor2format(runparams.flavor);
if (contains(path, ' '))
found_space = true;
+ string enc;
+ if (params().useBiblatex() && !params().bibFileEncoding(utf8input).empty())
+ enc = params().bibFileEncoding(utf8input);
+
+ bool recorded = false;
+ for (pair<docstring, string> pe : res) {
+ if (pe.first == path) {
+ recorded = true;
+ break;
+ }
- if (find(res.begin(), res.end(), path) == res.end())
- res.push_back(path);
+ }
+ if (!recorded)
+ res.push_back(make_pair(path, enc));
}
// Check if there are spaces in the path and warn BibTeX users, if so.
ListOfBuffers Buffer::allRelatives() const
{
- ListOfBuffers lb = masterBuffer()->getDescendents();
+ ListOfBuffers lb = masterBuffer()->getDescendants();
lb.push_front(const_cast<Buffer *>(masterBuffer()));
return lb;
}
}
-ListOfBuffers Buffer::getDescendents() const
+ListOfBuffers Buffer::getDescendants() const
{
ListOfBuffers v;
collectChildren(v, true);
if (it == m.begin())
return m.end();
- it--;
+ --it;
return it;
}
if (d->parent())
return const_cast<Buffer *>(masterBuffer())->getReferenceCache(label);
- // In what follows, we look whether we find an active label
- // with the given string in the cache. If so, return its
- // references cache. If we only find an inactive one, return
- // that (the last we find, coincidentally). If we find noting,
- // return an empty references cache.
- static LabelInfo linfo;
- linfo.inset = nullptr;
- linfo.references = References();
- linfo.active = false;
- bool have_inactive = false;
- for (auto & rc : d->ref_cache_) {
- if (rc.label == label) {
- if (rc.active)
- return rc.references;
- else {
- linfo = rc;
- have_inactive = true;
- }
- }
- }
-
- if (!have_inactive)
- // We found nothing, so insert the empty one to the cache
- // for further processing
- d->ref_cache_.push_back(linfo);
+ RefCache::iterator it = d->ref_cache_.find(label);
+ if (it != d->ref_cache_.end())
+ return it->second;
- return linfo.references;
+ static References const dummy_refs = References();
+ it = d->ref_cache_.insert(
+ make_pair(label, dummy_refs)).first;
+ return it->second;
}
void Buffer::setInsetLabel(docstring const & label, InsetLabel const * il,
bool const active)
{
- static LabelInfo linfo;
+ LabelInfo linfo;
linfo.label = label;
linfo.inset = il;
- linfo.references = References();
linfo.active = active;
- masterBuffer()->d->ref_cache_.push_back(linfo);
+ masterBuffer()->d->label_cache_.push_back(linfo);
}
InsetLabel const * Buffer::insetLabel(docstring const & label,
bool const active) const
{
- for (auto & rc : masterBuffer()->d->ref_cache_) {
+ for (auto & rc : masterBuffer()->d->label_cache_) {
if (rc.label == label && (rc.active || !active))
return rc.inset;
}
bool Buffer::activeLabel(docstring const & label) const
{
- if (!insetLabel(label))
+ if (!insetLabel(label, true))
return false;
- for (auto & rc : masterBuffer()->d->ref_cache_) {
- if (rc.label == label && rc.active)
- return true;
- }
- return false;
+ return true;
}
void Buffer::clearReferenceCache() const
{
- if (!d->parent())
+ if (!d->parent()) {
d->ref_cache_.clear();
+ d->label_cache_.clear();
+ }
}
void Buffer::setExportStatus(bool e) const
{
d->doing_export = e;
- ListOfBuffers clist = getDescendents();
+ ListOfBuffers clist = getDescendants();
for (auto const & bit : clist)
bit->d->doing_export = e;
}
if (!put_in_tempdir) {
// Only show this alert if this is an export to a non-temporary
// file (not for previewing).
- Alert::error(_("Couldn't export file"), bformat(
- _("No information for exporting the format %1$s."),
- theFormats().prettyName(format)));
+ docstring s = bformat(_("No information for exporting the format %1$s."),
+ theFormats().prettyName(format));
+ if (format == "pdf4")
+ s += "\n"
+ + 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);
}
return ExportNoPathToFormat;
}
bformat(_("The directory path to the document\n%1$s\n"
"contains spaces, but your TeX installation does "
"not allow them. You should save the file to a directory "
- "whose name does not contain spaces."), from_ascii(filePath())));
+ "whose name does not contain spaces."), from_utf8(filePath())));
return ExportTexPathHasSpaces;
} else {
runparams.nice = false;
else
errors(error_type);
// also to the children, in case of master-buffer-view
- ListOfBuffers clist = getDescendents();
+ ListOfBuffers clist = getDescendants();
for (auto const & bit : clist) {
if (runparams.silent)
bit->d->errorLists[error_type].clear();
result_file = dest_filename;
// We need to copy referenced files (e. g. included graphics
// if format == "dvi") to the result dir.
- vector<ExportedFile> const files =
+ vector<ExportedFile> const extfiles =
runparams.exportdata->externalFiles(format);
string const dest = runparams.export_folder.empty() ?
onlyPath(result_file) : runparams.export_folder;
: force_overwrite == ALL_FILES;
CopyStatus status = use_force ? FORCE : SUCCESS;
- for (ExportedFile const & exp : files) {
+ for (ExportedFile const & exp : extfiles) {
if (status == CANCEL) {
message(_("Document export cancelled."));
return ExportCancel;
Impl * theimpl = isClone() ? d->cloned_buffer_->d : d;
theimpl->preview_file_ = previewFile;
theimpl->preview_format_ = format;
- theimpl->preview_error_ = (status != ExportSuccess);
+ theimpl->require_fresh_start_ = (status != ExportSuccess);
if (status != ExportSuccess)
return status;
_("&Remove"), _("&Keep"));
if (del_emerg == 0)
emergencyFile.removeFile();
+ else {
+ // See bug #11464
+ FileName newname;
+ string const ename = emergencyFile.absFileName();
+ bool noname = true;
+ // Surely we can find one in 100 tries?
+ for (int i = 1; i < 100; ++i) {
+ newname.set(ename + to_string(i) + ".lyx");
+ if (!newname.exists()) {
+ noname = false;
+ break;
+ }
+ }
+ if (!noname) {
+ // renameTo returns true on success. So inverting that
+ // will give us true if we fail.
+ noname = !emergencyFile.renameTo(newname);
+ }
+ if (noname) {
+ Alert::warning(_("Can't rename emergency file!"),
+ _("LyX was unable to rename the emergency file. "
+ "You should do so manually. Otherwise, you will be "
+ "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"),
+ bformat(_("Emergency file renamed as:\n %1$s"),
+ from_utf8(newname.onlyFileName())));
+ }
+ }
return ReadOriginal;
}
}
-void Buffer::bufferErrors(TeXErrors const & terr, ErrorList & errorList) const
+void Buffer::Impl::traverseErrors(TeXErrors::Errors::const_iterator err, TeXErrors::Errors::const_iterator end, ErrorList & errorList) const
{
- for (auto const & err : terr) {
+ for (; err != end; ++err) {
TexRow::TextEntry start = TexRow::text_none, end = TexRow::text_none;
- int errorRow = err.error_in_line;
+ int errorRow = err->error_in_line;
Buffer const * buf = 0;
- Impl const * p = d;
- if (err.child_name.empty())
+ Impl const * p = this;
+ if (err->child_name.empty())
tie(start, end) = p->texrow.getEntriesFromRow(errorRow);
else {
// The error occurred in a child
- for (Buffer const * child : getDescendents()) {
+ for (Buffer const * child : owner_->getDescendants()) {
string const child_name =
DocFileName(changeExtension(child->absFileName(), "tex")).
mangledFileName();
- if (err.child_name != child_name)
+ if (err->child_name != child_name)
continue;
tie(start, end) = child->d->texrow.getEntriesFromRow(errorRow);
if (!TexRow::isNone(start)) {
- buf = d->cloned_buffer_
+ buf = this->cloned_buffer_
? child->d->cloned_buffer_->d->owner_
: child->d->owner_;
p = child->d;
}
}
}
- errorList.push_back(ErrorItem(err.error_desc, err.error_text,
+ errorList.push_back(ErrorItem(err->error_desc, err->error_text,
start, end, buf));
}
}
+void Buffer::bufferErrors(TeXErrors const & terr, ErrorList & errorList) const
+{
+ TeXErrors::Errors::const_iterator err = terr.begin();
+ TeXErrors::Errors::const_iterator end = terr.end();
+
+ d->traverseErrors(err, end, errorList);
+}
+
+
+void Buffer::bufferRefs(TeXErrors const & terr, ErrorList & errorList) const
+{
+ TeXErrors::Errors::const_iterator err = terr.begin_ref();
+ TeXErrors::Errors::const_iterator end = terr.end_ref();
+
+ d->traverseErrors(err, end, errorList);
+}
+
+
void Buffer::updateBuffer(UpdateScope scope, UpdateType utype) const
{
LBUFERR(!text().paragraphs().empty());
// update all caches
clearReferenceCache();
updateMacros();
- setChangesPresent(false);
Buffer & cbuf = const_cast<Buffer &>(*this);
+ // if we are reloading, then we could have a dangling TOC,
+ // in effect. so we need to go ahead and reset, even though
+ // we will do so again when we rebuild the TOC later.
+ cbuf.tocBackend().reset();
// do the real work
ParIterator parit = cbuf.par_iterator_begin();
clearReferenceCache();
// we should not need to do this again?
// updateMacros();
- setChangesPresent(false);
updateBuffer(parit, utype);
// this will already have been done by reloadBibInfoCache();
// d->bibinfo_cache_valid_ = true;
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:
- itemlabel = char_type(0x2219); // or 0x00b7
+ // · U+00B7 MIDDLE DOT
+ itemlabel = char_type(0x00b7);
break;
}
par.params().labelString(itemlabel);
// to resolve macros in it.
parit.text()->setMacrocontextPosition(parit);
+ // Reset bibitem counter in master (#8499)
+ Buffer const * const master = masterBuffer();
+ if (master == this && !d->ignore_parent)
+ master->params().documentClass().counters().reset(from_ascii("bibitem"));
+
depth_type maxdepth = 0;
pit_type const lastpit = parit.lastpit();
for ( ; parit.pit() <= lastpit ; ++parit.pit()) {
// set the counter for this paragraph
d->setLabel(parit, utype);
- // update change-tracking flag
- parit->addChangesToBuffer(*this);
-
// now the insets
for (auto const & insit : parit->insetList()) {
parit.pos() = insit.pos;
}
-void Buffer::setChangesPresent(bool b) const
-{
- d->tracked_changes_present_ = b;
-}
-
-
-bool Buffer::areChangesPresent() const
-{
- return d->tracked_changes_present_;
-}
-
-
-void Buffer::updateChangesPresent() const
-{
- LYXERR(Debug::CHANGES, "Buffer::updateChangesPresent");
- setChangesPresent(false);
- ParConstIterator it = par_iterator_begin();
- ParConstIterator const end = par_iterator_end();
- for (; !areChangesPresent() && it != end; ++it)
- it->addChangesToBuffer(*this);
-}
-
-
void Buffer::Impl::refreshFileMonitor()
{
if (file_monitor_ && file_monitor_->filename() == filename.absFileName()) {
projects / lyx.git / blobdiff