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

[lyx.git] / src / DocIterator.h

diff --git a/src/DocIterator.h b/src/DocIterator.h
index 117e92383fe71fd5f035aa2ecbd9c80b719f6cf0..6e730ea685018f6b85116c6adbdffdb07469b39e 100644 (file)
--- a/src/DocIterator.h
+++ b/src/DocIterator.h
@@ -15,22 +15,14 @@
 #include "CursorSlice.h"
 
 #include <vector>
-#include <iosfwd>
 
 
 namespace lyx {
 
-class LyXText;
+class LyXErr;
 class MathAtom;
 class Paragraph;
-
-
-// only needed for gcc 2.95, remove when support terminated
-template <typename A, typename B>
-bool ptr_cmp(A const * a, B const * b)
-{
-       return a == b;
-}
+class Text;
 
 
 // The public inheritance should go in favour of a suitable data member
@@ -115,11 +107,9 @@ public:
        /// return the last column of the top grid
        col_type lastcol() const { return ncols() - 1; }
        /// the inset just behind the cursor
-       Inset * nextInset();
+       Inset * nextInset() const;
        /// the inset just in front of the cursor
-       Inset * prevInset();
-       /// the inset just in front of the cursor
-       Inset const * prevInset() const;
+       Inset * prevInset() const;
        ///
        bool boundary() const { return boundary_; }
        ///
@@ -138,43 +128,35 @@ public:
        // math-specific part
        //
        /// return the mathed cell this cursor is in
-       MathData const & cell() const;
-       /// return the mathed cell this cursor is in
-       MathData & cell();
-       /// the mathatom left of the cursor
-       MathAtom const & prevAtom() const;
+       MathData & cell() const;
        /// the mathatom left of the cursor
-       MathAtom & prevAtom();
+       MathAtom & prevAtom() const;
        /// the mathatom right of the cursor
-       MathAtom const & nextAtom() const;
-       /// the mathatom right of the cursor
-       MathAtom & nextAtom();
+       MathAtom & nextAtom() const;
 
-       //
        // text-specific part
        //
-       /// the paragraph we're in
-       Paragraph & paragraph();
-       /// the paragraph we're in
-       Paragraph const & paragraph() const;
+       /// the paragraph we're in in text mode.
+       /// \warning only works within text!
+       Paragraph & paragraph() const;
+       /// the paragraph we're in in any case.
+       /// This method will give the containing paragraph even
+       /// if not in text mode (ex: in mathed).
+       Paragraph & innerParagraph() const;
+       /// return the inner text slice.
+       CursorSlice const & innerTextSlice() const;
        ///
-       LyXText * text();
-       ///
-       LyXText const * text() const;
+       Text * text() const;
        /// the containing inset or the cell, respectively
        Inset * realInset() const;
        ///
        Inset * innerInsetOfType(int code) const;
        ///
-       LyXText * innerText();
-       ///
-       LyXText const * innerText() const;
+       Text * innerText() const;
 
        //
        // elementary moving
        //
-       /// move on one logical position, do not descend into nested insets
-       void forwardPosNoDescend();
        /**
         * move on one logical position, descend into nested insets
         * skip collapsed insets if \p ignorecollapsed is true
@@ -184,8 +166,6 @@ public:
        void forwardChar();
        /// move on one paragraph
        void forwardPar();
-       /// move on one cell
-       void forwardIdx();
        /// move on one inset
        void forwardInset();
        /// move backward one logical position
@@ -194,8 +174,6 @@ public:
        void backwardChar();
        /// move backward one paragraph
        void backwardPar();
-       /// move backward one cell
-       void backwardIdx();
        /// move backward one inset
        /// FIXME: This is not implemented!
        //void backwardInset();
@@ -206,8 +184,12 @@ public:
        /// output
        friend std::ostream &
        operator<<(std::ostream & os, DocIterator const & cur);
+       friend LyXErr & operator<<(LyXErr & os, DocIterator const & it);
        ///
        friend bool operator==(DocIterator const &, DocIterator const &);
+       friend bool operator<(DocIterator const &, DocIterator const &);
+       friend bool operator>(DocIterator const &, DocIterator const &);
+       friend bool operator<=(DocIterator const &, DocIterator const &);
        ///
        friend class StableDocIterator;
 //protected:
@@ -219,6 +201,22 @@ public:
        void pop_back() { slices_.pop_back(); }
        /// recompute the inset parts of the cursor from the document data
        void updateInsets(Inset * inset);
+       /// fix DocIterator in circumstances that should never happen.
+       /// \return true if the DocIterator was fixed.
+       bool fixIfBroken();
+
+       /// find index of CursorSlice with &cell() == &cell (or -1 if not found)
+       idx_type find(MathData const & cell) const;
+       /// find index of CursorSlice with inset() == inset (or -1 of not found)
+       idx_type find(InsetMath const * inset) const;
+       /// cut off CursorSlices with index > above and store cut off slices in cut
+       void cutOff(idx_type above, std::vector<CursorSlice> & cut);
+       /// cut off CursorSlices with index > above
+       void cutOff(idx_type above);
+       /// push CursorSlices on top
+       void append(std::vector<CursorSlice> const & x);
+       /// push one CursorSlice on top and set its index and position
+       void append(idx_type idx, pos_type pos);
 
 private:
        /**
@@ -252,20 +250,44 @@ DocIterator doc_iterator_begin(Inset & inset);
 DocIterator doc_iterator_end(Inset & inset);
 
 
-inline
-bool operator==(DocIterator const & di1, DocIterator const & di2)
+inline bool operator==(DocIterator const & di1, DocIterator const & di2)
 {
        return di1.slices_ == di2.slices_;
 }
 
 
-inline
-bool operator!=(DocIterator const & di1, DocIterator const & di2)
+inline bool operator!=(DocIterator const & di1, DocIterator const & di2)
 {
        return !(di1 == di2);
 }
 
 
+inline
+bool operator<(DocIterator const & p, DocIterator const & q)
+{
+       size_t depth = std::min(p.depth(), q.depth());
+       for (size_t i = 0 ; i < depth ; ++i) {
+               if (p[i] != q[i])
+                       return p[i] < q[i];
+       }
+       return p.depth() < q.depth();
+}
+
+
+inline 
+bool operator>(DocIterator const & p, DocIterator const & q)
+{
+       return q < p;
+}
+
+
+inline 
+bool operator<=(DocIterator const & p, DocIterator const & q)
+{
+       return !(q < p);
+}
+
+
 // The difference to a ('non stable') DocIterator is the removed
 // (overwritten by 0...) part of the CursorSlice data items. So this thing
 // is suitable for external storage, but not for iteration as such.