Embedding: saving inzip name to .lyx file so that embedded files can always be found...

[lyx.git] / src / buffer_funcs.cpp

diff --git a/src/buffer_funcs.cpp b/src/buffer_funcs.cpp
index c29fe0543906a9275af3aa1a81cb2396c9a243a6..23ad4eb1284fa5a4d3127ffa6403ed57915c47a1 100644 (file)
--- a/src/buffer_funcs.cpp
+++ b/src/buffer_funcs.cpp
@@ -16,13 +16,11 @@
 #include "Buffer.h"
 #include "BufferList.h"
 #include "BufferParams.h"
-#include "debug.h"
 #include "DocIterator.h"
 #include "Counters.h"
 #include "ErrorList.h"
 #include "Floating.h"
 #include "FloatList.h"
-#include "gettext.h"
 #include "InsetList.h"
 #include "InsetIterator.h"
 #include "Language.h"
@@ -46,28 +44,17 @@
 #include "insets/InsetBibitem.h"
 #include "insets/InsetInclude.h"
 
+#include "support/convert.h"
+#include "support/debug.h"
 #include "support/filetools.h"
-#include "support/fs_extras.h"
-#include "support/lyxlib.h"
-
-#include <boost/bind.hpp>
-
-using std::min;
-using std::string;
-
-
-namespace lyx {
+#include "support/gettext.h"
+#include "support/lstrings.h"
+#include "support/textutils.h"
 
 using namespace std;
+using namespace lyx::support;
 
-using support::bformat;
-using support::FileName;
-using support::libFileSearch;
-using support::makeAbsPath;
-using support::makeDisplayPath;
-using support::onlyFilename;
-using support::onlyPath;
-using support::unlink;
+namespace lyx {
 
 namespace Alert = frontend::Alert;
 
@@ -88,15 +75,16 @@ Buffer * checkAndLoadLyXFile(FileName const & filename)
                        return checkBuffer;
 
                // FIXME: should be LFUN_REVERT
-               if (theBufferList().close(checkBuffer, false))
-                       // Load it again.
-                       return checkAndLoadLyXFile(filename);
-               // The file could not be closed.
-               return 0;
+               theBufferList().release(checkBuffer);
+               // Load it again.
+               return checkAndLoadLyXFile(filename);
        }
 
-       if (filename.isReadable()) {
+       if (filename.isReadableFile()) {
                Buffer * b = theBufferList().newBuffer(filename.absFilename());
+               if (!b)
+                       // Buffer creation is not possible.
+                       return 0;
                if (!b->loadLyXFile(filename)) {
                        theBufferList().release(b);
                        return 0;
@@ -121,7 +109,9 @@ Buffer * newFile(string const & filename, string const & templatename,
 {
        // get a free buffer
        Buffer * b = theBufferList().newBuffer(filename);
-       BOOST_ASSERT(b);
+       if (!b)
+               // Buffer creation is not possible.
+               return 0;
 
        FileName tname;
        // use defaults.lyx as a default template if it exists.
@@ -154,6 +144,23 @@ Buffer * newFile(string const & filename, string const & templatename,
 }
 
 
+Buffer * newUnnamedFile(string const & templatename, FileName const & path)
+{
+       static int newfile_number;
+
+       string document_path = path.absFilename();
+       string filename = addName(document_path,
+               "newfile" + convert<string>(++newfile_number) + ".lyx");
+       while (theBufferList().exists(filename)
+               || FileName(filename).isReadableFile()) {
+               ++newfile_number;
+               filename = addName(document_path,
+                       "newfile" +     convert<string>(newfile_number) + ".lyx");
+       }
+       return newFile(filename, templatename, false);
+}
+
+
 int countWords(DocIterator const & from, DocIterator const & to)
 {
        int count = 0;
@@ -176,6 +183,33 @@ int countWords(DocIterator const & from, DocIterator const & to)
 }
 
 
+int countChars(DocIterator const & from, DocIterator const & to, bool with_blanks)
+{
+       int chars = 0;
+       int blanks = 0;
+       for (DocIterator dit = from ; dit != to ; dit.forwardPos()) {
+               if (dit.inTexted()
+                   && dit.pos() != dit.lastpos()
+                   && !dit.paragraph().isDeleted(dit.pos())) {
+                       if (dit.paragraph().isInset(dit.pos())) {
+                               if (dit.paragraph().getInset(dit.pos())->isLetter())
+                                       ++chars;
+                               else if (dit.paragraph().getInset(dit.pos())->isSpace() && with_blanks)
+                                       ++blanks;
+                       } else {
+                               char_type const c = dit.paragraph().getChar(dit.pos());
+                               if (isPrintableNonspace(c))
+                                       ++chars;
+                               else if (isSpace(c) && with_blanks)
+                                       ++blanks;
+                       }
+               }
+       }
+
+       return chars + blanks;
+}
+
+
 namespace {
 
 depth_type getDepth(DocIterator const & it)
@@ -216,19 +250,16 @@ depth_type getItemDepth(ParIterator const & it)
                Paragraph & prev_par = *prev_it;
                depth_type const prev_depth = getDepth(prev_it);
                if (labeltype == prev_par.layout()->labeltype) {
-                       if (prev_depth < min_depth) {
+                       if (prev_depth < min_depth)
                                return prev_par.itemdepth + 1;
-                       }
-                       else if (prev_depth == min_depth) {
+                       if (prev_depth == min_depth)
                                return prev_par.itemdepth;
-                       }
                }
-               min_depth = std::min(min_depth, prev_depth);
+               min_depth = min(min_depth, prev_depth);
                // small optimization: if we are at depth 0, we won't
                // find anything else
-               if (prev_depth == 0) {
+               if (prev_depth == 0)
                        return 0;
-               }
        }
 }
 
@@ -407,6 +438,12 @@ void updateLabels(Buffer const & buf, ParIterator & parit)
 {
        BOOST_ASSERT(parit.pit() == 0);
 
+       // set the position of the text in the buffer to be able
+       // to resolve macros in it. This has nothing to do with
+       // labels, but by putting it here we avoid implementing
+       // a whole bunch of traversal routines just for this call.
+       parit.text()->setMacrocontextPosition(parit);
+
        depth_type maxdepth = 0;
        pit_type const lastpit = parit.lastpit();
        for ( ; parit.pit() <= lastpit ; ++parit.pit()) {
@@ -472,7 +509,7 @@ void updateLabels(Buffer const & buf, bool childonly)
 void checkBufferStructure(Buffer & buffer, ParIterator const & par_it)
 {
        if (par_it->layout()->toclevel != Layout::NOT_IN_TOC) {
-               Buffer * master = buffer.masterBuffer();
+               Buffer const * master = buffer.masterBuffer();
                master->tocBackend().updateItem(par_it);
                master->structureChanged();
        }