Fix a copy-paste error introduced in b754fb02

[lyx.git] / src / Buffer.cpp

diff --git a/src/Buffer.cpp b/src/Buffer.cpp
index 8c1ea58e4aaef5fa6eed8e94180fa654493a7c2c..d5e337603c58d734500a905bf46824cacf3b4e87 100644 (file)
--- a/src/Buffer.cpp
+++ b/src/Buffer.cpp
@@ -309,11 +309,27 @@ public:
        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_;
+
 };
 
 
@@ -773,6 +789,7 @@ int Buffer::readHeader(Lexer & lex)
        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];
@@ -986,7 +1003,7 @@ Buffer::ReadStatus Buffer::readFile(FileName const & fn)
 
        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;
 }
@@ -1492,9 +1509,8 @@ void Buffer::writeLaTeXSource(otexstream & os,
                        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!");
@@ -3293,6 +3309,12 @@ void Buffer::getSourceCode(odocstream & os, string const format,
                        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 {
                        // latex or literate
                        otexstream ots(os, texrow);
@@ -3715,13 +3737,11 @@ Buffer::ExportStatus Buffer::doExport(string const & target, bool put_in_tempdir
        // LaTeX backend
        else if (backend_format == format) {
                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"),
@@ -3729,13 +3749,12 @@ Buffer::ExportStatus Buffer::doExport(string const & target, bool put_in_tempdir
                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")
@@ -4427,6 +4446,77 @@ int Buffer::spellCheck(DocIterator & from, DocIterator & to,
 }
 
 
+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()
 {
        setBusy(true);
@@ -4436,6 +4526,8 @@ Buffer::ReadStatus Buffer::reload()
        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();