fix #1073

[lyx.git] / src / mathed / math_iterator.C

diff --git a/src/mathed/math_iterator.C b/src/mathed/math_iterator.C
index 9d4e9c11baa9f933bb0dbe5a8e9823673a077069..eb73b1a3a38b310e8573728d91f5c815b97e4e3c 100644 (file)
--- a/src/mathed/math_iterator.C
+++ b/src/mathed/math_iterator.C
@@ -2,12 +2,13 @@
 #include <config.h>
 
 #include "math_iterator.h"
+#include "math_inset.h"
 #include "debug.h"
 #include "support/LAssert.h"
 
 
-//MathIterator::MathIterator()
-//{}
+MathIterator::MathIterator()
+{}
 
 
 MathIterator::MathIterator(MathInset * p)
@@ -16,32 +17,21 @@ MathIterator::MathIterator(MathInset * p)
 }
 
 
-//MathIterator::MathIterator(MathCursor::cursor_type const & c)
-//     : cursor_(c)
-//{}
-
-
-MathCursor::cursor_type const & MathIterator::cursor() const
-{
-       return cursor_;
-}
-
-
 MathInset const * MathIterator::par() const
 {
-       return position().par_;
+       return back().par_;
 }
 
 
 MathInset * MathIterator::par()
 {
-       return position().par_;
+       return back().par_;
 }
 
 
 MathArray const & MathIterator::cell() const
 {
-       MathCursorPos const & top = position();
+       MathCursorPos const & top = back();
        return top.par_->cell(top.idx_);
 }
 
@@ -50,33 +40,33 @@ MathArray const & MathIterator::cell() const
 void MathIterator::push(MathInset * p)
 {
        //lyxerr << "push: " << p << endl;
-       cursor_.push_back(MathCursorPos(p));
+       push_back(MathCursorPos(p));
 }
 
 
 void MathIterator::pop()
 {
        //lyxerr << "pop: " << endl;
-       lyx::Assert(cursor_.size());
-       cursor_.pop_back();
+       lyx::Assert(size());
+       pop_back();
 }
 
 
 MathCursorPos const & MathIterator::operator*() const
 {
-       return position();
+       return back();
 }
 
 
 MathCursorPos const & MathIterator::operator->() const
 {
-       return position();
+       return back();
 }
 
 
 void MathIterator::goEnd()
 {
-       MathCursorPos & top = position();
+       MathCursorPos & top = back();
        top.idx_ = top.par_->nargs() - 1;
        top.pos_ = cell().size();
 }
@@ -84,8 +74,8 @@ void MathIterator::goEnd()
 
 void MathIterator::operator++()
 {
-       MathCursorPos   & top = position();
-       MathArray const & ar  = top.par_->cell(top.idx_);
+       MathCursorPos & top = back();
+       MathArray     & ar  = top.par_->cell(top.idx_);
 
        // move into the current inset if possible
        // it is impossible for pos() == size()!
@@ -97,7 +87,7 @@ void MathIterator::operator++()
                return;
        }
 
-       // otherwise move on one cell position if possible
+       // otherwise move on one cell back if possible
        if (top.pos_ < ar.size()) {
                // pos() == size() is valid!
                ++top.pos_;
@@ -114,37 +104,44 @@ void MathIterator::operator++()
                }
        }
 
-       // otherwise leave array, move on one position
+       // otherwise leave array, move on one back
        // this might yield pos() == size(), but that's a ok.
-       pop(); 
+       pop();
        // it certainly invalidates top
-       ++position().pos_;
+       ++back().pos_;
+}
+
+
+void MathIterator::jump(difference_type i)
+{
+       back().pos_ += i;
+       //lyx::Assert(back().pos_ >= 0);
+       lyx::Assert(back().pos_ <= cell().size());
+}
+
+
+bool MathIterator::normal() const
+{
+       return back().pos_ < cell().size();
 }
 
 
-void MathIterator::jump(MathInset::difference_type i)
+void MathIterator::shrink(size_type i)
 {
-       position().pos_ += i;
-       //lyx::Assert(position().pos_ >= 0);
-       lyx::Assert(position().pos_ <= cell().size());
+       if (i < size())
+               erase(begin() + i, end());
 }
 
 
 bool operator==(MathIterator const & it, MathIterator const & jt)
 {
-       //lyxerr << "==: " << it.cursor().size() << " " << jt.cursor().size() << endl;
-       if (it.cursor().size() != jt.cursor().size())
-               return false;
-       return it.cursor() == jt.cursor();      
+       return MathIterator::base_type(it) == MathIterator::base_type(jt);
 }
 
 
 bool operator!=(MathIterator const & it, MathIterator const & jt)
 {
-       //lyxerr << "!=: " << it.cursor().size() << " " << jt.cursor().size() << endl;
-       if (it.cursor().size() != jt.cursor().size())
-               return true;
-       return it.cursor() != jt.cursor();      
+       return MathIterator::base_type(it) != MathIterator::base_type(jt);
 }