#include "Chktex.h"
#include "Converter.h"
#include "Counters.h"
-#include "debug.h"
#include "DocIterator.h"
#include "EmbeddedFiles.h"
#include "Encoding.h"
#include "Exporter.h"
#include "Format.h"
#include "FuncRequest.h"
-#include "gettext.h"
#include "InsetIterator.h"
#include "InsetList.h"
#include "Language.h"
#include "graphics/Previews.h"
-#include "support/types.h"
-#include "support/lyxalgo.h"
+#include "support/convert.h"
+#include "support/debug.h"
#include "support/FileFilterList.h"
#include "support/filetools.h"
-#include "support/Forkedcall.h"
+#include "support/ForkedCalls.h"
+#include "support/gettext.h"
#include "support/gzstream.h"
#include "support/lstrings.h"
+#include "support/lyxalgo.h"
#include "support/lyxlib.h"
#include "support/os.h"
#include "support/Path.h"
#include "support/textutils.h"
-#include "support/convert.h"
+#include "support/types.h"
#if !defined (HAVE_FORK)
# define fork() -1
using support::subst;
using support::tempName;
using support::trim;
-using support::sum;
using support::suffixIs;
namespace Alert = frontend::Alert;
namespace {
-int const LYX_FORMAT = 300; // Uwe: \pagebreak
+int const LYX_FORMAT = 303; // Uwe: Serbocroatian
} // namespace anon
BufferParams params;
LyXVC lyxvc;
string temppath;
- TexRow texrow;
+ mutable TexRow texrow;
+ Buffer const * parent_buffer;
/// need to regenerate .tex?
DepClean dep_clean;
InsetText inset;
///
- TocBackend toc_backend;
+ mutable TocBackend toc_backend;
/// macro table
typedef std::map<unsigned int, MacroData, std::greater<int> > PositionToMacroMap;
Buffer::Impl::Impl(Buffer & parent, FileName const & file, bool readonly_)
- : lyx_clean(true), bak_clean(true), unnamed(false), read_only(readonly_),
- filename(file), file_fully_loaded(false), inset(params),
- toc_backend(&parent), embedded_files(&parent), timestamp_(0),
- checksum_(0), wa_(0), undo_(parent)
+ : parent_buffer(0), lyx_clean(true), bak_clean(true), unnamed(false),
+ read_only(readonly_), filename(file), file_fully_loaded(false),
+ inset(params), toc_backend(&parent), embedded_files(&parent),
+ timestamp_(0), checksum_(0), wa_(0), undo_(parent)
{
inset.setAutoBreakRows(true);
lyxvc.setBuffer(&parent);
temppath = createBufferTmpDir();
- params.filepath = onlyPath(file.absFilename());
+
// FIXME: And now do something if temppath == string(), because we
// assume from now on that temppath points to a valid temp dir.
// See http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg67406.html
Buffer::Buffer(string const & file, bool readonly)
- : pimpl_(new Impl(*this, FileName(file), readonly)), gui_(0)
+ : d(new Impl(*this, FileName(file), readonly)), gui_(0)
{
LYXERR(Debug::INFO, "Buffer::Buffer()");
}
// here the buffer should take care that it is
// saved properly, before it goes into the void.
- Buffer * master = masterBuffer();
+ Buffer const * master = masterBuffer();
if (master != this && use_gui)
// We are closing buf which was a child document so we
// must update the labels and section numbering of its master
// Buffer.
updateLabels(*master);
+ resetChildDocuments(false);
+
if (!temppath().empty() && !FileName(temppath()).destroyDirectory()) {
Alert::warning(_("Could not remove temporary directory"),
bformat(_("Could not remove the temporary directory %1$s"),
// Remove any previewed LaTeX snippets associated with this buffer.
graphics::Previews::get().removeLoader(*this);
- if (pimpl_->wa_) {
- pimpl_->wa_->closeAll();
- delete pimpl_->wa_;
+ if (d->wa_) {
+ d->wa_->closeAll();
+ delete d->wa_;
}
- delete pimpl_;
+ delete d;
}
void Buffer::changed() const
{
- if (pimpl_->wa_)
- pimpl_->wa_->redrawAll();
+ if (d->wa_)
+ d->wa_->redrawAll();
}
frontend::WorkAreaManager & Buffer::workAreaManager() const
{
- BOOST_ASSERT(pimpl_->wa_);
- return *pimpl_->wa_;
+ BOOST_ASSERT(d->wa_);
+ return *d->wa_;
}
Text & Buffer::text() const
{
- return const_cast<Text &>(pimpl_->inset.text_);
+ return const_cast<Text &>(d->inset.text_);
}
Inset & Buffer::inset() const
{
- return const_cast<InsetText &>(pimpl_->inset);
+ return const_cast<InsetText &>(d->inset);
}
BufferParams & Buffer::params()
{
- return pimpl_->params;
+ return d->params;
}
BufferParams const & Buffer::params() const
{
- return pimpl_->params;
+ return d->params;
}
LyXVC & Buffer::lyxvc()
{
- return pimpl_->lyxvc;
+ return d->lyxvc;
}
LyXVC const & Buffer::lyxvc() const
{
- return pimpl_->lyxvc;
+ return d->lyxvc;
}
string const & Buffer::temppath() const
{
- return pimpl_->temppath;
-}
-
-
-TexRow & Buffer::texrow()
-{
- return pimpl_->texrow;
+ return d->temppath;
}
TexRow const & Buffer::texrow() const
{
- return pimpl_->texrow;
-}
-
-
-TocBackend & Buffer::tocBackend()
-{
- return pimpl_->toc_backend;
+ return d->texrow;
}
-TocBackend const & Buffer::tocBackend() const
+TocBackend & Buffer::tocBackend() const
{
- return pimpl_->toc_backend;
+ return d->toc_backend;
}
EmbeddedFiles & Buffer::embeddedFiles()
{
- return pimpl_->embedded_files;
+ return d->embedded_files;
}
EmbeddedFiles const & Buffer::embeddedFiles() const
{
- return pimpl_->embedded_files;
+ return d->embedded_files;
}
Undo & Buffer::undo()
{
- return pimpl_->undo_;
+ return d->undo_;
}
string Buffer::latexName(bool const no_path) const
{
- string const name = changeExtension(makeLatexName(absFileName()), ".tex");
- return no_path ? onlyFilename(name) : name;
+ FileName latex_name = makeLatexName(d->filename);
+ return no_path ? latex_name.onlyFileName()
+ : latex_name.absFilename();
}
void Buffer::setReadonly(bool const flag)
{
- if (pimpl_->read_only != flag) {
- pimpl_->read_only = flag;
+ if (d->read_only != flag) {
+ d->read_only = flag;
setReadOnly(flag);
}
}
void Buffer::setFileName(string const & newfile)
{
- pimpl_->filename = makeAbsPath(newfile);
- params().filepath = onlyPath(pimpl_->filename.absFilename());
- setReadonly(pimpl_->filename.isReadOnly());
+ d->filename = makeAbsPath(newfile);
+ setReadonly(d->filename.isReadOnly());
updateTitles();
}
params().temp_bullet(i) = ITEMIZE_DEFAULTS[i];
}
- ErrorList & errorList = pimpl_->errorLists["Parse"];
+ ErrorList & errorList = d->errorLists["Parse"];
while (lex.isOK()) {
lex.next();
LYXERR(Debug::PARSER, "Handling document header token: `"
<< token << '\'');
- string unknown = params().readToken(lex, token);
+ string unknown = params().readToken(lex, token, d->filename.onlyPath());
if (!unknown.empty()) {
if (unknown[0] != '\\' && token == "\\textclass") {
Alert::warning(_("Unknown document class"),
// Returns false if "\end_document" is not read (Asger)
bool Buffer::readDocument(Lexer & lex)
{
- ErrorList & errorList = pimpl_->errorLists["Parse"];
+ ErrorList & errorList = d->errorLists["Parse"];
errorList.clear();
lex.next();
bool Buffer::isFullyLoaded() const
{
- return pimpl_->file_fully_loaded;
+ return d->file_fully_loaded;
}
void Buffer::setFullyLoaded(bool value)
{
- pimpl_->file_fully_loaded = value;
+ d->file_fully_loaded = value;
}
// save timestamp and checksum of the original disk file, making sure
// to not overwrite them with those of the file created in the tempdir
// when it has to be converted to the current format.
- if (!pimpl_->checksum_) {
+ if (!d->checksum_) {
// Save the timestamp and checksum of disk file. If filename is an
- // emergency file, save the timestamp and sum of the original lyx file
+ // emergency file, save the timestamp and checksum of the original lyx file
// because isExternallyModified will check for this file. (BUG4193)
string diskfile = filename.absFilename();
if (suffixIs(diskfile, ".emergency"))
from_utf8(filename.absFilename())));
}
- pimpl_->file_fully_loaded = true;
+ d->file_fully_loaded = true;
return success;
}
// We don't need autosaves in the immediate future. (Asger)
resetAutosaveTimers();
- string const encodedFilename = pimpl_->filename.toFilesystemEncoding();
+ string const encodedFilename = d->filename.toFilesystemEncoding();
FileName backupName;
bool madeBackup = false;
backupName = FileName(absFileName() + '~');
if (!lyxrc.backupdir_path.empty()) {
string const mangledName =
- subst(subst(os::internal_path(
- backupName.absFilename()), '/', '!'), ':', '!');
+ subst(subst(backupName.absFilename(), '/', '!'), ':', '!');
backupName = FileName(addName(lyxrc.backupdir_path,
mangledName));
}
- if (fileName().copyTo(backupName, false)) {
+ if (fileName().copyTo(backupName, true)) {
madeBackup = true;
} else {
Alert::error(_("Backup failure"),
return false;
}
- if (writeFile(pimpl_->filename)) {
+ if (writeFile(d->filename)) {
markClean();
removeAutosaveFile(absFileName());
- saveCheckSum(pimpl_->filename);
+ saveCheckSum(d->filename);
return true;
} else {
// Saving failed, so backup is not backup
if (madeBackup)
- rename(backupName, pimpl_->filename);
+ rename(backupName, d->filename);
return false;
}
}
bool Buffer::writeFile(FileName const & fname) const
{
- if (pimpl_->read_only && fname == pimpl_->filename)
+ if (d->read_only && fname == d->filename)
return false;
bool retval = false;
if (retval && params().embedded) {
// write file.lyx and all the embedded files to the zip file fname
// if embedding is enabled
- return pimpl_->embedded_files.writeFile(fname);
+ return d->embedded_files.writeFile(fname);
}
return retval;
}
bool Buffer::makeLaTeXFile(FileName const & fname,
string const & original_path,
OutputParams const & runparams,
- bool output_preamble, bool output_body)
+ bool output_preamble, bool output_body) const
{
string const encoding = runparams.encoding->iconvName();
LYXERR(Debug::LATEX, "makeLaTeXFile encoding: " << encoding << "...");
bool failed_export = false;
try {
- texrow().reset();
+ d->texrow.reset();
writeLaTeXSource(ofs, original_path,
runparams, output_preamble, output_body);
}
void Buffer::writeLaTeXSource(odocstream & os,
string const & original_path,
OutputParams const & runparams_in,
- bool const output_preamble, bool const output_body)
+ bool const output_preamble, bool const output_body) const
{
OutputParams runparams = runparams_in;
"For more info, see http://www.lyx.org/.\n"
"%% Do not edit unless you really know what "
"you are doing.\n";
- texrow().newline();
- texrow().newline();
+ d->texrow.newline();
+ d->texrow.newline();
}
LYXERR(Debug::INFO, "lyx document header finished");
// There are a few differences between nice LaTeX and usual files:
// code for usual, NOT nice-latex-file
os << "\\batchmode\n"; // changed
// from \nonstopmode
- texrow().newline();
+ d->texrow.newline();
}
if (!original_path.empty()) {
// FIXME UNICODE
<< "\\def\\input@path{{"
<< inputpath << "/}}\n"
<< "\\makeatother\n";
- texrow().newline();
- texrow().newline();
- texrow().newline();
+ d->texrow.newline();
+ d->texrow.newline();
+ d->texrow.newline();
}
// Write the preamble
- runparams.use_babel = params().writeLaTeX(os, features, texrow());
+ runparams.use_babel = params().writeLaTeX(os, features, d->texrow);
if (!output_body)
return;
// make the body.
os << "\\begin{document}\n";
- texrow().newline();
+ d->texrow.newline();
} // output_preamble
- texrow().start(paragraphs().begin()->id(), 0);
+ d->texrow.start(paragraphs().begin()->id(), 0);
LYXERR(Debug::INFO, "preamble finished, now the body.");
"$$lang",
params().language->babel()))
<< '\n';
- texrow().newline();
+ d->texrow.newline();
}
Encoding const & encoding = params().encoding();
// the preamble if it is handled by CJK.sty.
os << "\\begin{CJK}{" << from_ascii(encoding.latexName())
<< "}{}\n";
- texrow().newline();
+ d->texrow.newline();
}
// if we are doing a real file with body, even if this is the
// child of some other buffer, let's cut the link here.
// This happens for example if only a child document is printed.
- string save_parentname;
+ Buffer const * save_parent = 0;
if (output_preamble) {
- save_parentname = params().parentname;
- params().parentname.erase();
+ save_parent = d->parent_buffer;
+ d->parent_buffer = 0;
}
loadChildDocuments();
// the real stuff
- latexParagraphs(*this, paragraphs(), os, texrow(), runparams);
+ latexParagraphs(*this, paragraphs(), os, d->texrow, runparams);
// Restore the parenthood if needed
if (output_preamble)
- params().parentname = save_parentname;
+ d->parent_buffer = save_parent;
// add this just in case after all the paragraphs
os << endl;
- texrow().newline();
+ d->texrow.newline();
if (encoding.package() == Encoding::CJK) {
// Close the open CJK environment.
// latexParagraphs will have opened one even if the last text
// was not CJK.
os << "\\end{CJK}\n";
- texrow().newline();
+ d->texrow.newline();
}
if (!lyxrc.language_auto_end &&
"$$lang",
params().language->babel()))
<< '\n';
- texrow().newline();
+ d->texrow.newline();
}
if (output_preamble) {
os << "\\end{document}\n";
- texrow().newline();
+ d->texrow.newline();
LYXERR(Debug::LATEX, "makeLaTeXFile...done");
} else {
LYXERR(Debug::LATEX, "LaTeXFile for inclusion made.");
runparams_in.encoding = runparams.encoding;
// Just to be sure. (Asger)
- texrow().newline();
+ d->texrow.newline();
LYXERR(Debug::INFO, "Finished making LaTeX file.");
- LYXERR(Debug::INFO, "Row count was " << texrow().rows() - 1 << '.');
+ LYXERR(Debug::INFO, "Row count was " << d->texrow.rows() - 1 << '.');
}
void Buffer::makeDocBookFile(FileName const & fname,
OutputParams const & runparams,
- bool const body_only)
+ bool const body_only) const
{
LYXERR(Debug::LATEX, "makeDocBookFile...");
void Buffer::writeDocBookSource(odocstream & os, string const & fname,
OutputParams const & runparams,
- bool const only_body)
+ bool const only_body) const
{
LaTeXFeatures features(*this, params(), runparams);
validate(features);
- texrow().reset();
+ d->texrow.reset();
TextClass const & tclass = params().getTextClass();
string const top_element = tclass.latexname();
Alert::error(_("chktex failure"),
_("Could not run chktex successfully."));
} else if (res > 0) {
- ErrorList & errlist = pimpl_->errorLists["ChkTeX"];
+ ErrorList & errlist = d->errorLists["ChkTeX"];
errlist.clear();
bufferErrors(terr, errlist);
}
}
-void Buffer::updateBibfilesCache()
+void Buffer::updateBibfilesCache() const
{
// if this is a child document and the parent is already loaded
// update the parent's cache instead
- Buffer * tmp = masterBuffer();
+ Buffer const * tmp = masterBuffer();
BOOST_ASSERT(tmp);
if (tmp != this) {
tmp->updateBibfilesCache();
bool Buffer::isDepClean(string const & name) const
{
- DepClean::const_iterator const it = pimpl_->dep_clean.find(name);
- if (it == pimpl_->dep_clean.end())
+ DepClean::const_iterator const it = d->dep_clean.find(name);
+ if (it == d->dep_clean.end())
return true;
return it->second;
}
void Buffer::markDepClean(string const & name)
{
- pimpl_->dep_clean[name] = true;
+ d->dep_clean[name] = true;
}
bool Buffer::isClean() const
{
- return pimpl_->lyx_clean;
+ return d->lyx_clean;
}
bool Buffer::isBakClean() const
{
- return pimpl_->bak_clean;
+ return d->bak_clean;
}
bool Buffer::isExternallyModified(CheckMethod method) const
{
- BOOST_ASSERT(pimpl_->filename.exists());
+ BOOST_ASSERT(d->filename.exists());
// if method == timestamp, check timestamp before checksum
return (method == checksum_method
- || pimpl_->timestamp_ != pimpl_->filename.lastModified())
- && pimpl_->checksum_ != sum(pimpl_->filename);
+ || d->timestamp_ != d->filename.lastModified())
+ && d->checksum_ != d->filename.checksum();
}
void Buffer::saveCheckSum(FileName const & file) const
{
if (file.exists()) {
- pimpl_->timestamp_ = file.lastModified();
- pimpl_->checksum_ = sum(file);
+ d->timestamp_ = file.lastModified();
+ d->checksum_ = file.checksum();
} else {
// in the case of save to a new file.
- pimpl_->timestamp_ = 0;
- pimpl_->checksum_ = 0;
+ d->timestamp_ = 0;
+ d->checksum_ = 0;
}
}
void Buffer::markClean() const
{
- if (!pimpl_->lyx_clean) {
- pimpl_->lyx_clean = true;
+ if (!d->lyx_clean) {
+ d->lyx_clean = true;
updateTitles();
}
// if the .lyx file has been saved, we don't need an
// autosave
- pimpl_->bak_clean = true;
+ d->bak_clean = true;
}
void Buffer::markBakClean() const
{
- pimpl_->bak_clean = true;
+ d->bak_clean = true;
}
void Buffer::setUnnamed(bool flag)
{
- pimpl_->unnamed = flag;
+ d->unnamed = flag;
}
bool Buffer::isUnnamed() const
{
- return pimpl_->unnamed;
+ return d->unnamed;
}
// FIXME: this function should be moved to buffer_pimpl.C
void Buffer::markDirty()
{
- if (pimpl_->lyx_clean) {
- pimpl_->lyx_clean = false;
+ if (d->lyx_clean) {
+ d->lyx_clean = false;
updateTitles();
}
- pimpl_->bak_clean = false;
+ d->bak_clean = false;
- DepClean::iterator it = pimpl_->dep_clean.begin();
- DepClean::const_iterator const end = pimpl_->dep_clean.end();
+ DepClean::iterator it = d->dep_clean.begin();
+ DepClean::const_iterator const end = d->dep_clean.end();
for (; it != end; ++it)
it->second = false;
FileName Buffer::fileName() const
{
- return pimpl_->filename;
+ return d->filename;
}
string Buffer::absFileName() const
{
- return pimpl_->filename.absFilename();
+ return d->filename.absFilename();
}
-string const & Buffer::filePath() const
+string Buffer::filePath() const
{
- return params().filepath;
+ return d->filename.onlyPath().absFilename();
}
bool Buffer::isReadonly() const
{
- return pimpl_->read_only;
+ return d->read_only;
}
-void Buffer::setParentName(string const & name)
+void Buffer::setParent(Buffer const * buffer)
{
- if (name == pimpl_->filename.absFilename())
- // Avoids recursive include.
- params().parentname.clear();
- else
- params().parentname = name;
+ // Avoids recursive include.
+ d->parent_buffer = buffer == this ? 0 : buffer;
}
-Buffer const * Buffer::masterBuffer() const
+Buffer const * Buffer::parent()
{
- if (!params().parentname.empty()
- && theBufferList().exists(params().parentname)) {
- Buffer const * buf = theBufferList().getBuffer(params().parentname);
- //We need to check if the parent is us...
- //FIXME RECURSIVE INCLUDE
- //This is not sufficient, since recursive includes could be downstream.
- if (buf && buf != this)
- return buf->masterBuffer();
- }
-
- return this;
+ return d->parent_buffer;
}
-Buffer * Buffer::masterBuffer()
+Buffer const * Buffer::masterBuffer() const
{
- if (!params().parentname.empty()
- && theBufferList().exists(params().parentname)) {
- Buffer * buf = theBufferList().getBuffer(params().parentname);
- //We need to check if the parent is us...
- //FIXME RECURSIVE INCLUDE
- //This is not sufficient, since recursive includes could be downstream.
- if (buf && buf != this)
- return buf->masterBuffer();
- }
-
- return this;
+ if (!d->parent_buffer)
+ return this;
+
+ return d->parent_buffer->masterBuffer();
}
bool Buffer::hasMacro(docstring const & name, Paragraph const & par) const
{
Impl::PositionToMacroMap::iterator it;
- it = pimpl_->macros[name].upper_bound(par.macrocontextPosition());
- if (it != pimpl_->macros[name].end())
+ it = d->macros[name].upper_bound(par.macrocontextPosition());
+ if (it != d->macros[name].end())
return true;
// If there is a master buffer, query that
- const Buffer * master = masterBuffer();
+ Buffer const * master = masterBuffer();
if (master && master != this)
return master->hasMacro(name);
bool Buffer::hasMacro(docstring const & name) const
{
- if( !pimpl_->macros[name].empty() )
+ if( !d->macros[name].empty() )
return true;
// If there is a master buffer, query that
- const Buffer * master = masterBuffer();
+ Buffer const * master = masterBuffer();
if (master && master != this)
return master->hasMacro(name);
Paragraph const & par) const
{
Impl::PositionToMacroMap::iterator it;
- it = pimpl_->macros[name].upper_bound(par.macrocontextPosition());
- if( it != pimpl_->macros[name].end() )
+ it = d->macros[name].upper_bound(par.macrocontextPosition());
+ if( it != d->macros[name].end() )
return it->second;
// If there is a master buffer, query that
- const Buffer * master = masterBuffer();
+ Buffer const * master = masterBuffer();
if (master && master != this)
return master->getMacro(name);
MacroData const & Buffer::getMacro(docstring const & name) const
{
Impl::PositionToMacroMap::iterator it;
- it = pimpl_->macros[name].begin();
- if( it != pimpl_->macros[name].end() )
+ it = d->macros[name].begin();
+ if( it != d->macros[name].end() )
return it->second;
// If there is a master buffer, query that
- const Buffer * master = masterBuffer();
+ Buffer const * master = masterBuffer();
if (master && master != this)
return master->getMacro(name);
void Buffer::updateMacros()
{
// start with empty table
- pimpl_->macros = Impl::NameToPositionMacroMap();
+ d->macros = Impl::NameToPositionMacroMap();
// Iterate over buffer
ParagraphList & pars = text().paragraphs();
macro.setRedefinition(hasMacro(macroTemplate.name()));
// register macro (possibly overwrite the previous one of this paragraph)
- pimpl_->macros[macroTemplate.name()][i] = macro;
+ d->macros[macroTemplate.name()][i] = macro;
}
}
}
// No side effect of file copying and image conversion
runparams.dryrun = true;
- texrow().reset();
+ d->texrow.reset();
if (full_source) {
os << "% " << _("Preview source code") << "\n\n";
- texrow().newline();
- texrow().newline();
+ d->texrow.newline();
+ d->texrow.newline();
if (isLatex())
writeLaTeXSource(os, filePath(), runparams, true, true);
else {
convert<docstring>(par_begin),
convert<docstring>(par_end - 1))
<< "\n\n";
- texrow().newline();
- texrow().newline();
+ d->texrow.newline();
+ d->texrow.newline();
// output paragraphs
if (isLatex()) {
- latexParagraphs(*this, paragraphs(), os, texrow(), runparams);
+ latexParagraphs(*this, paragraphs(), os, d->texrow, runparams);
} else {
// DocBook
docbookParagraphs(paragraphs(), *this, os, runparams);
}
-ErrorList const & Buffer::errorList(string const & type) const
+ErrorList & Buffer::errorList(string const & type) const
{
- static ErrorList const emptyErrorList;
- std::map<string, ErrorList>::const_iterator I = pimpl_->errorLists.find(type);
- if (I == pimpl_->errorLists.end())
+ static ErrorList emptyErrorList;
+ std::map<string, ErrorList>::iterator I = d->errorLists.find(type);
+ if (I == d->errorLists.end())
return emptyErrorList;
return I->second;
}
-ErrorList & Buffer::errorList(string const & type)
-{
- return pimpl_->errorLists[type];
-}
-
-
void Buffer::structureChanged() const
{
if (gui_)
void Buffer::setReadOnly(bool on) const
{
- if (pimpl_->wa_)
- pimpl_->wa_->setReadOnly(on);
+ if (d->wa_)
+ d->wa_->setReadOnly(on);
}
void Buffer::updateTitles() const
{
- if (pimpl_->wa_)
- pimpl_->wa_->updateTitles();
+ if (d->wa_)
+ d->wa_->updateTitles();
}
// filesystems unless write of tmp_ret
// failed so remove tmp file (if it
// exists)
- unlink(tmp_ret);
+ tmp_ret.removeFile();
}
} else {
failed = true;
}
+void Buffer::resetChildDocuments(bool close_them) const
+{
+ for (InsetIterator it = inset_iterator_begin(inset()); it; ++it) {
+ if (it->lyxCode() != INCLUDE_CODE)
+ continue;
+ InsetCommand const & inset = static_cast<InsetCommand const &>(*it);
+ InsetCommandParams const & ip = inset.params();
+
+ resetParentBuffer(this, ip, close_them);
+ }
+
+ if (use_gui && masterBuffer() == this)
+ updateLabels(*this);
+}
+
+
void Buffer::loadChildDocuments() const
{
bool parse_error = false;
bool Buffer::doExport(string const & format, bool put_in_tempdir,
- string & result_file)
+ string & result_file) const
{
string backend_format;
OutputParams runparams(¶ms().encoding());
}
-bool Buffer::doExport(string const & format, bool put_in_tempdir)
+bool Buffer::doExport(string const & format, bool put_in_tempdir) const
{
string result_file;
return doExport(format, put_in_tempdir, result_file);
}
-bool Buffer::preview(string const & format)
+bool Buffer::preview(string const & format) const
{
string result_file;
if (!doExport(format, true, result_file))
return readFile(a);
case 1:
// Here we delete the autosave
- unlink(a);
+ a.removeFile();
break;
default:
return false;
int id_start = -1;
int pos_start = -1;
int errorRow = cit->error_in_line;
- bool found = texrow().getIdFromRow(errorRow, id_start,
+ bool found = d->texrow.getIdFromRow(errorRow, id_start,
pos_start);
int id_end = -1;
int pos_end = -1;
do {
++errorRow;
- found = texrow().getIdFromRow(errorRow, id_end, pos_end);
+ found = d->texrow.getIdFromRow(errorRow, id_end, pos_end);
} while (found && id_start == id_end && pos_start == pos_end);
errorList.push_back(ErrorItem(cit->error_desc,
projects / lyx.git / blobdiff