#include "Chktex.h"
#include "Converter.h"
#include "Counters.h"
+#include "Cursor.h"
#include "DispatchResult.h"
#include "DocIterator.h"
#include "Encoding.h"
#include <map>
#include <set>
#include <sstream>
-#include <stack>
#include <vector>
using namespace std;
/// is this an unnamed file (New...)?
bool unnamed;
+ /// is this an internal bufffer?
+ bool internal_buffer;
+
/// buffer is r/o
bool read_only;
*/
bool file_fully_loaded;
+ /// Ignore the parent (e.g. when exporting a child standalone)?
+ bool ignore_parent;
+
///
mutable TocBackend toc_backend;
/// This is here to force the test to be done whenever parent_buffer
/// is accessed.
- Buffer const * parent() const {
+ Buffer const * parent() const
+ {
+ // ignore_parent temporarily "orphans" a buffer
+ // (e.g. if a child is compiled standalone)
+ if (ignore_parent)
+ return 0;
// if parent_buffer is not loaded, then it has been unloaded,
// which means that parent_buffer is an invalid pointer. So we
// set it to null in that case.
}
///
- void setParent(Buffer const * pb) {
+ void setParent(Buffer const * pb)
+ {
if (parent_buffer == pb)
// nothing to do
return;
CloneList * clone_list_;
/// are we in the process of exporting this buffer?
mutable bool doing_export;
+
+ /// compute statistics
+ /// \p from initial position
+ /// \p to points to the end position
+ void updateStatistics(DocIterator & from, DocIterator & to,
+ bool skipNoOutput = true);
+ /// statistics accessor functions
+ int wordCount() const
+ {
+ return word_count_;
+ }
+ int charCount(bool with_blanks) const
+ {
+ return char_count_
+ + (with_blanks ? blank_count_ : 0);
+ }
private:
/// So we can force access via the accessors.
mutable Buffer const * parent_buffer;
+ int word_count_;
+ int char_count_;
+ int blank_count_;
+
};
Buffer::Impl::Impl(Buffer * owner, FileName const & file, bool readonly_,
Buffer const * cloned_buffer)
: owner_(owner), lyx_clean(true), bak_clean(true), unnamed(false),
- read_only(readonly_), filename(file), file_fully_loaded(false),
- toc_backend(owner), macro_lock(false), timestamp_(0), checksum_(0),
- wa_(0), gui_(0), undo_(*owner), bibinfo_cache_valid_(false),
- bibfile_cache_valid_(false), cite_labels_valid_(false),
- preview_loader_(0), cloned_buffer_(cloned_buffer), clone_list_(0),
+ internal_buffer(false), read_only(readonly_), filename(file),
+ file_fully_loaded(false), ignore_parent(false), toc_backend(owner),
+ macro_lock(false), timestamp_(0), checksum_(0), wa_(0), gui_(0),
+ undo_(*owner), bibinfo_cache_valid_(false), bibfile_cache_valid_(false),
+ cite_labels_valid_(false), preview_loader_(0),
+ cloned_buffer_(cloned_buffer), clone_list_(0),
doing_export(false), parent_buffer(0)
{
if (!cloned_buffer_) {
bibfile_status_ = cloned_buffer_->d->bibfile_status_;
cite_labels_valid_ = cloned_buffer_->d->cite_labels_valid_;
unnamed = cloned_buffer_->d->unnamed;
+ internal_buffer = cloned_buffer_->d->internal_buffer;
}
Buffer * Buffer::cloneFromMaster() const
{
BufferMap bufmap;
- cloned_buffers.push_back(new CloneList());
+ cloned_buffers.push_back(new CloneList);
CloneList * clones = cloned_buffers.back();
masterBuffer()->cloneWithChildren(bufmap, clones);
Buffer * Buffer::cloneBufferOnly() const {
- cloned_buffers.push_back(new CloneList());
+ cloned_buffers.push_back(new CloneList);
CloneList * clones = cloned_buffers.back();
Buffer * buffer_clone = new Buffer(fileName().absFileName(), false, this);
clones->insert(buffer_clone);
params().html_latex_end.clear();
params().html_math_img_scale = 1.0;
params().output_sync_macro.erase();
+ params().local_layout.clear();
for (int i = 0; i < 4; ++i) {
params().user_defined_bullet(i) = ITEMIZE_DEFAULTS[i];
d->file_fully_loaded = true;
d->read_only = !d->filename.isWritable();
- params().compressed = d->filename.isZippedFile();
+ params().compressed = formats.isZippedFile(d->filename);
saveCheckSum();
return ReadSuccess;
}
ofdocstream ofs;
try { ofs.reset(encoding); }
- catch (iconv_codecvt_facet_exception & e) {
+ 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 "
os.texrow().reset();
writeLaTeXSource(os, original_path, runparams, output);
}
- catch (EncodingException & e) {
+ catch (EncodingException const & e) {
odocstringstream ods;
ods.put(e.failed_char);
ostringstream oss;
e.par_id, e.pos, e.pos + 1));
failed_export = true;
}
- catch (iconv_codecvt_facet_exception & e) {
+ catch (iconv_codecvt_facet_exception const & e) {
errorList.push_back(ErrorItem(_("iconv conversion failed"),
_(e.what()), -1, 0, 0));
failed_export = true;
void Buffer::writeLaTeXSource(otexstream & os,
string const & original_path,
OutputParams const & runparams_in,
- OutputWhat output) const
+ OutputWhat output) const
{
// The child documents, if any, shall be already loaded at this point.
OutputParams runparams = runparams_in;
+ // If we are compiling a file standalone, even if this is the
+ // child of some other buffer, let's cut the link here, so the
+ // file is really independent and no concurring settings from
+ // the master (e.g. branch state) interfere (see #8100).
+ if (!runparams.is_child)
+ d->ignore_parent = true;
+
// Classify the unicode characters appearing in math insets
Encodings::initUnicodeMath(*this);
LYXERR(Debug::LATEX, " Validating buffer...");
LaTeXFeatures features(*this, params(), runparams);
validate(features);
+ runparams.use_polyglossia = features.usePolyglossia();
LYXERR(Debug::LATEX, " Buffer validation done.");
bool const output_preamble =
output == FullSource || output == OnlyPreamble;
bool const output_body =
- output == FullSource || output == OnlyBody;
+ output == FullSource || output == OnlyBody;
// The starting paragraph of the coming rows is the
// first paragraph of the document. (Asger)
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) {
+ if (!enc->encodable(inputpath[n])) {
+ docstring const glyph(1, inputpath[n]);
LYXERR0("Uncodable character '"
<< glyph
<< "' in input path!");
MacroSet parentMacros;
listParentMacros(parentMacros, features);
- runparams.use_polyglossia = features.usePolyglossia();
// Write the preamble
runparams.use_babel = params().writeLaTeX(os, features,
d->filename.onlyPath());
runparams.use_japanese = features.isRequired("japanese");
- if (!output_body)
+ if (!output_body) {
+ // Restore the parenthood if needed
+ if (!runparams.is_child)
+ d->ignore_parent = false;
return;
+ }
// make the body.
os << "\\begin{document}\n";
LYXERR(Debug::INFO, "preamble finished, now the body.");
- // 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.
- Buffer const * save_parent = 0;
- if (output_preamble) {
- save_parent = d->parent();
- d->setParent(0);
- }
-
// the real stuff
latexParagraphs(*this, text(), os, runparams);
// Restore the parenthood if needed
- if (output_preamble)
- d->setParent(save_parent);
+ if (!runparams.is_child)
+ d->ignore_parent = false;
// add this just in case after all the paragraphs
os << endl;
bool const output_preamble =
output == FullSource || output == OnlyPreamble;
bool const output_body =
- output == FullSource || output == OnlyBody;
+ 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/TR/MathML2/dtd/xhtml-math11-f.dtd\">\n"
+ << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN\" \"http://www.w3.org/TR/2001/REC-MathML2-20010221/dtd/xhtml-math11-f.dtd\">\n"
// FIXME Language should be set properly.
<< "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
<< "<head>\n"
html::htmlize(doctitle, XHTMLStream::ESCAPE_ALL))
<< "</title>\n";
- os << "\n<!-- Text Class Preamble -->\n"
- << features.getTClassHTMLPreamble()
- << "\n<!-- Preamble Snippets -->\n"
- << from_utf8(features.getPreambleSnippets());
+ docstring styles = features.getTClassHTMLPreamble();
+ if (!styles.empty())
+ os << "\n<!-- Text Class Preamble -->\n" << styles << '\n';
+
+ styles = from_utf8(features.getPreambleSnippets());
+ if (!styles.empty())
+ os << "\n<!-- Preamble Snippets -->\n" << styles << '\n';
// we will collect CSS information in a stream, and then output it
// either here, as part of the header, or else in a separate file.
odocstringstream css;
- docstring styles = from_utf8(features.getCSSSnippets());
+ styles = from_utf8(features.getCSSSnippets());
if (!styles.empty())
css << "/* LyX Provided Styles */\n" << styles << '\n';
docstring const dstyles = css.str();
if (!dstyles.empty()) {
- os << "<style type='text/css'>\n"
- << dstyles
- << "\n</style>\n";
+ bool written = false;
+ if (params().html_css_as_file) {
+ // open a file for CSS info
+ ofdocstream ocss;
+ string const fcssname = addName(temppath(), "docstyle.css");
+ FileName const fcssfile = FileName(fcssname);
+ if (openFileWrite(ocss, fcssfile)) {
+ ocss << dstyles;
+ ocss.close();
+ written = true;
+ // write link to header
+ os << "<link rel='stylesheet' href='docstyle.css' type='text/css' />\n";
+ // register file
+ runparams.exportdata->addExternalFile("xhtml", fcssfile);
+ }
+ }
+ // 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"
+ << dstyles
+ << "\n</style>\n";
+ }
}
os << "</head>\n";
}
if (output_body) {
- os << "<body>\n";
+ bool const output_body_tag = (output != IncludedFile);
+ if (output_body_tag)
+ os << "<body>\n";
XHTMLStream xs(os);
params().documentClass().counters().reset();
xhtmlParagraphs(text(), *this, xs, runparams);
- os << "</body>\n";
+ if (output_body_tag)
+ os << "</body>\n";
}
if (output_preamble)
void Buffer::validate(LaTeXFeatures & features) const
{
- params().validate(features);
+ // Validate the buffer params, but not for included
+ // files, since they also use the parent buffer's
+ // params (# 5941)
+ if (!features.runparams().is_child)
+ params().validate(features);
for_each(paragraphs().begin(), paragraphs().end(),
bind(&Paragraph::validate, _1, ref(features)));
if (it->lyxCode() == BRANCH_CODE) {
InsetBranch & ins = static_cast<InsetBranch &>(*it);
if (ins.branch() == oldname) {
- undo().recordUndo(it);
+ undo().recordUndo(CursorData(it));
ins.rename(newname);
success = true;
continue;
/// retrieving fileName() nor for checking if it is unnamed or not.
bool Buffer::isInternal() const
{
- return fileName().extension() == "internal";
+ return d->internal_buffer;
+}
+
+
+void Buffer::setInternal(bool flag)
+{
+ d->internal_buffer = flag;
}
string Buffer::filePath() const
{
- return d->filename.onlyPath().absFileName() + "/";
+ int last = d->filename.onlyPath().absFileName().length() - 1;
+
+ return d->filename.onlyPath().absFileName()[last] == '/'
+ ? d->filename.onlyPath().absFileName()
+ : d->filename.onlyPath().absFileName() + "/";
}
// try previous macro if there is one
if (it == nameIt->second.begin())
break;
- it--;
+ --it;
}
}
}
void Buffer::getSourceCode(odocstream & os, string const format,
pit_type par_begin, pit_type par_end,
- OutputWhat output) const
+ OutputWhat output, bool master) const
{
OutputParams runparams(¶ms().encoding());
runparams.nice = true;
convert<docstring>(par_end - 1))
<< "\n\n";
}
- TexRow texrow;
- texrow.reset();
- texrow.newline();
- texrow.newline();
// output paragraphs
- if (params().isDocBook())
- docbookParagraphs(text(), *this, os, runparams);
- else if (runparams.flavor == OutputParams::HTML) {
+ if (runparams.flavor == OutputParams::LYX) {
+ Paragraph const & par = text().paragraphs()[par_begin];
+ ostringstream ods;
+ depth_type dt = par.getDepth();
+ par.write(ods, params(), dt);
+ os << from_utf8(ods.str());
+ } else if (runparams.flavor == OutputParams::HTML) {
XHTMLStream xs(os);
setMathFlavor(runparams);
xhtmlParagraphs(text(), *this, xs, runparams);
+ } else if (runparams.flavor == OutputParams::TEXT) {
+ bool dummy;
+ // FIXME Handles only one paragraph, unlike the others.
+ // Probably should have some routine with a signature like them.
+ writePlaintextParagraph(*this,
+ text().paragraphs()[par_begin], os, runparams, dummy);
+ } else if (params().isDocBook()) {
+ docbookParagraphs(text(), *this, os, runparams);
} else {
+ // If we are previewing a paragraph, even if this is the
+ // child of some other buffer, let's cut the link here,
+ // so that no concurring settings from the master
+ // (e.g. branch state) interfere (see #8101).
+ if (!master)
+ d->ignore_parent = true;
+ // We need to validate the Buffer params' features here
+ // in order to know if we should output polyglossia
+ // macros (instead of babel macros)
+ LaTeXFeatures features(*this, params(), runparams);
+ params().validate(features);
+ runparams.use_polyglossia = features.usePolyglossia();
+ TexRow texrow;
+ texrow.reset();
+ texrow.newline();
+ texrow.newline();
// latex or literate
otexstream ots(os, texrow);
+
+ // the real stuff
latexParagraphs(*this, text(), ots, runparams);
+
+ // Restore the parenthood
+ if (!master)
+ d->ignore_parent = false;
}
} else {
os << "% ";
else if (output == OnlyBody)
os << _("Preview body");
os << "\n\n";
- d->texrow.reset();
- d->texrow.newline();
- d->texrow.newline();
- if (params().isDocBook())
- writeDocBookSource(os, absFileName(), runparams, output);
- else if (runparams.flavor == OutputParams::HTML)
+ if (runparams.flavor == OutputParams::LYX) {
+ ostringstream ods;
+ if (output == FullSource)
+ write(ods);
+ else if (output == OnlyPreamble)
+ params().writeFile(ods);
+ else if (output == OnlyBody)
+ text().write(ods);
+ os << from_utf8(ods.str());
+ } else if (runparams.flavor == OutputParams::HTML) {
writeLyXHTMLSource(os, runparams, output);
- else {
+ } else if (runparams.flavor == OutputParams::TEXT) {
+ if (output == OnlyPreamble) {
+ os << "% "<< _("Plain text does not have a preamble.");
+ } else
+ writePlaintextFile(*this, os, runparams);
+ } else if (params().isDocBook()) {
+ writeDocBookSource(os, absFileName(), runparams, output);
+ } else {
// latex or literate
+ d->texrow.reset();
+ d->texrow.newline();
+ d->texrow.newline();
otexstream ots(os, d->texrow);
+ if (master)
+ runparams.is_child = true;
writeLaTeXSource(ots, string(), runparams, output);
}
}
buf->d->bak_clean = true;
FileName const fname = getAutosaveFileName();
- if (d->cloned_buffer_) {
- // If this buffer is cloned, we assume that
- // we are running in a separate thread already.
- FileName const tmp_ret = FileName::tempName("lyxauto");
- if (!tmp_ret.empty()) {
- writeFile(tmp_ret);
- // assume successful write of tmp_ret
- if (tmp_ret.moveTo(fname))
- return true;
- }
- // failed to write/rename tmp_ret so try writing direct
- return writeFile(fname);
- } else {
- /// This function is deprecated as the frontend needs to take care
- /// of cloning the buffer and autosaving it in another thread. It
- /// is still here to allow (QT_VERSION < 0x040400).
- AutoSaveBuffer autosave(*this, fname);
- autosave.start();
- return true;
+ LASSERT(d->cloned_buffer_, return false);
+
+ // If this buffer is cloned, we assume that
+ // we are running in a separate thread already.
+ FileName const tmp_ret = FileName::tempName("lyxauto");
+ if (!tmp_ret.empty()) {
+ writeFile(tmp_ret);
+ // assume successful write of tmp_ret
+ if (tmp_ret.moveTo(fname))
+ return true;
}
+ // failed to write/rename tmp_ret so try writing direct
+ return writeFile(fname);
}
runparams.includeall = includeall;
vector<string> backs = params().backends();
Converters converters = theConverters();
+ bool need_nice_file = false;
if (find(backs.begin(), backs.end(), format) == backs.end()) {
// Get shortest path to format
converters.buildGraph();
}
return ExportNoPathToFormat;
}
- runparams.flavor = converters.getFlavor(path);
+ runparams.flavor = converters.getFlavor(path, this);
+ Graph::EdgePath::const_iterator it = path.begin();
+ Graph::EdgePath::const_iterator en = path.end();
+ for (; it != en; ++it)
+ if (theConverters().get(*it).nice) {
+ need_nice_file = true;
+ break;
+ }
} else {
backend_format = format;
makeDocBookFile(FileName(filename), runparams);
}
// LaTeX backend
- else if (backend_format == format) {
+ else if (backend_format == format || need_nice_file) {
runparams.nice = true;
- if (!makeLaTeXFile(FileName(filename), string(), runparams)) {
- if (d->cloned_buffer_) {
- d->cloned_buffer_->d->errorLists["Export"] =
- d->errorLists["Export"];
- }
+ bool const success = makeLaTeXFile(FileName(filename), string(), runparams);
+ if (d->cloned_buffer_)
+ d->cloned_buffer_->d->errorLists["Export"] = d->errorLists["Export"];
+ if (!success)
return ExportError;
- }
} else if (!lyxrc.tex_allows_spaces
&& contains(filePath(), ' ')) {
Alert::error(_("File name error"),
return ExportTexPathHasSpaces;
} else {
runparams.nice = false;
- if (!makeLaTeXFile(FileName(filename), filePath(), runparams)) {
- if (d->cloned_buffer_) {
- d->cloned_buffer_->d->errorLists["Export"] =
- d->errorLists["Export"];
- }
+ bool const success = makeLaTeXFile(
+ FileName(filename), filePath(), runparams);
+ if (d->cloned_buffer_)
+ d->cloned_buffer_->d->errorLists["Export"] = d->errorLists["Export"];
+ if (!success)
return ExportError;
- }
}
string const error_type = (format == "program")
Counters & counters = textclass.counters();
if (par.params().startOfAppendix()) {
- // FIXME: only the counter corresponding to toplevel
- // sectioning should be reset
- counters.reset();
+ // We want to reset the counter corresponding to toplevel sectioning
+ Layout const & lay = textclass.getTOCLayout();
+ docstring const cnt = lay.counter;
+ if (!cnt.empty())
+ counters.reset(cnt);
counters.appendix(true);
}
par.params().appendix(counters.appendix());
pit_type const lastpit = parit.lastpit();
for ( ; parit.pit() <= lastpit ; ++parit.pit()) {
// reduce depth if necessary
- parit->params().depth(min(parit->params().depth(), maxdepth));
+ if (parit->params().depth() > maxdepth) {
+ /** FIXME: this function is const, but
+ * nevertheless it modifies the buffer. To be
+ * cleaner, one should modify the buffer in
+ * another function, which is actually
+ * non-const. This would however be costly in
+ * terms of code duplication.
+ */
+ const_cast<Buffer *>(this)->undo().recordUndo(CursorData(parit));
+ parit->params().depth(maxdepth);
+ }
maxdepth = parit->getMaxDepthAfter();
if (utype == OutputUpdate) {
}
-Buffer::ReadStatus Buffer::reload()
+void Buffer::Impl::updateStatistics(DocIterator & from, DocIterator & to, bool skipNoOutput)
+{
+ bool inword = false;
+ word_count_ = 0;
+ char_count_ = 0;
+ blank_count_ = 0;
+
+ for (DocIterator dit = from ; dit != to && !dit.atEnd(); ) {
+ if (!dit.inTexted()) {
+ dit.forwardPos();
+ continue;
+ }
+
+ Paragraph const & par = dit.paragraph();
+ pos_type const pos = dit.pos();
+
+ // Copied and adapted from isWordSeparator() in Paragraph
+ if (pos == dit.lastpos()) {
+ inword = false;
+ } else {
+ Inset const * ins = par.getInset(pos);
+ if (ins && skipNoOutput && !ins->producesOutput()) {
+ // skip this inset
+ ++dit.top().pos();
+ // stop if end of range was skipped
+ if (!to.atEnd() && dit >= to)
+ break;
+ continue;
+ } else if (!par.isDeleted(pos)) {
+ if (par.isWordSeparator(pos))
+ inword = false;
+ else if (!inword) {
+ ++word_count_;
+ inword = true;
+ }
+ if (ins && ins->isLetter())
+ ++char_count_;
+ else if (ins && ins->isSpace())
+ ++blank_count_;
+ else {
+ char_type const c = par.getChar(pos);
+ if (isPrintableNonspace(c))
+ ++char_count_;
+ else if (isSpace(c))
+ ++blank_count_;
+ }
+ }
+ }
+ dit.forwardPos();
+ }
+}
+
+
+void Buffer::updateStatistics(DocIterator & from, DocIterator & to, bool skipNoOutput) const
+{
+ d->updateStatistics(from, to, skipNoOutput);
+}
+
+
+int Buffer::wordCount() const
+{
+ return d->wordCount();
+}
+
+
+int Buffer::charCount(bool with_blanks) const
+{
+ return d->charCount(with_blanks);
+}
+
+
+Buffer::ReadStatus Buffer::reload(bool clearUndo)
{
setBusy(true);
// c.f. bug http://www.lyx.org/trac/ticket/6587
d->filename.refresh();
docstring const disp_fn = makeDisplayPath(d->filename.absFileName());
+ // clear parent. this will get reset if need be.
+ d->setParent(0);
ReadStatus const status = loadLyXFile();
if (status == ReadSuccess) {
updateBuffer();
updateTitles();
markClean();
message(bformat(_("Document %1$s reloaded."), disp_fn));
- d->undo_.clear();
+ if (clearUndo)
+ d->undo_.clear();
} else {
message(bformat(_("Could not reload document %1$s."), disp_fn));
}
// we need to check that the locations of child buffers
// are still valid.
checkChildBuffers();
+ checkMasterBuffer();
return true;
} else {
// save failed
d->position_to_children.clear();
}
+
+// If a child has been saved under a different name/path, it might have been
+// orphaned. Therefore the master needs to be reset (bug 8161).
+void Buffer::checkMasterBuffer()
+{
+ Buffer const * const master = masterBuffer();
+ if (master == this)
+ return;
+
+ // necessary to re-register the child (bug 5873)
+ // FIXME: clean up updateMacros (here, only
+ // child registering is needed).
+ master->updateMacros();
+ // (re)set master as master buffer, but only
+ // if we are a real child
+ if (master->isChild(this))
+ setParent(master);
+ else
+ setParent(0);
+}
+
} // namespace lyx