X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fdociterator.C;h=f0bf8da06988cc805d8bcf79d0810ca8fa7b6aea;hb=1fa0fb5c67656cacbe3cfe6e8b08dd98cada1f73;hp=d4d51819ef886f5430652566ea45b6494b6246d9;hpb=0d43ba149a41e8860dde316ccbd4336d6b0bbdfa;p=lyx.git

diff --git a/src/dociterator.C b/src/dociterator.C
index d4d51819ef..f0bf8da069 100644
--- a/src/dociterator.C
+++ b/src/dociterator.C
@@ -1,3 +1,16 @@
+/**
+ * \file dociterator.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author unknown
+ * \author Lars Gullik Bjønnes
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+
+#include <config.h>
 
 #include "dociterator.h"
 
@@ -14,50 +27,66 @@
 using std::endl;
 
 
-DocumentIterator::DocumentIterator()
+// We could be able to get rid of this if only every BufferView were
+// associated to a buffer on construction.
+DocIterator::DocIterator()
+	: inset_(0)
+{}
+
+
+DocIterator::DocIterator(InsetBase & inset)
+	: inset_(&inset)
 {}
 
 
-DocumentIterator::DocumentIterator(InsetBase & inset)
+DocIterator doc_iterator_begin(InsetBase & inset)
 {
-	push_back(CursorSlice(inset));
+	DocIterator dit(inset);
+	dit.forwardPos();
+	return dit;
 }
 
 
-InsetBase * DocumentIterator::nextInset()
+DocIterator doc_iterator_end(InsetBase & inset)
+{
+	return DocIterator(inset);
+}
+
+
+InsetBase * DocIterator::nextInset()
 {
 	BOOST_ASSERT(!empty());
 	if (pos() == lastpos())
 		return 0;
-	if (inMathed()) 
+	if (inMathed())
 		return nextAtom().nucleus();
 	return paragraph().isInset(pos()) ? paragraph().getInset(pos()) : 0;
 }
 
 
-InsetBase * DocumentIterator::prevInset()
+InsetBase * DocIterator::prevInset()
 {
 	BOOST_ASSERT(!empty());
 	if (pos() == 0)
 		return 0;
-	if (inMathed()) 
+	if (inMathed())
 		return prevAtom().nucleus();
 	return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
 }
 
 
-InsetBase const * DocumentIterator::prevInset() const
+InsetBase const * DocIterator::prevInset() const
 {
 	BOOST_ASSERT(!empty());
 	if (pos() == 0)
 		return 0;
-	if (inMathed()) 
+	if (inMathed())
 		return prevAtom().nucleus();
 	return paragraph().isInset(pos() - 1) ? paragraph().getInset(pos() - 1) : 0;
 }
 
 
-MathAtom const & DocumentIterator::prevAtom() const
+MathAtom const & DocIterator::prevAtom() const
 {
 	BOOST_ASSERT(!empty());
 	BOOST_ASSERT(pos() > 0);
@@ -65,7 +94,7 @@ MathAtom const & DocumentIterator::prevAtom() const
 }
 
 
-MathAtom & DocumentIterator::prevAtom()
+MathAtom & DocIterator::prevAtom()
 {
 	BOOST_ASSERT(!empty());
 	BOOST_ASSERT(pos() > 0);
@@ -73,145 +102,147 @@ MathAtom & DocumentIterator::prevAtom()
 }
 
 
-MathAtom const & DocumentIterator::nextAtom() const
+MathAtom const & DocIterator::nextAtom() const
 {
 	BOOST_ASSERT(!empty());
+	//lyxerr << "lastpos: " << lastpos() << " next atom:\n" << *this << endl;
 	BOOST_ASSERT(pos() < lastpos());
 	return cell()[pos()];
 }
 
 
-MathAtom & DocumentIterator::nextAtom()
+MathAtom & DocIterator::nextAtom()
 {
 	BOOST_ASSERT(!empty());
+	//lyxerr << "lastpos: " << lastpos() << " next atom:\n" << *this << endl;
 	BOOST_ASSERT(pos() < lastpos());
 	return cell()[pos()];
 }
 
 
-LyXText * DocumentIterator::text() const
+LyXText * DocIterator::text() const
 {
 	BOOST_ASSERT(!empty());
 	return top().text();
 }
 
 
-Paragraph & DocumentIterator::paragraph()
+Paragraph & DocIterator::paragraph()
 {
 	BOOST_ASSERT(inTexted());
 	return top().paragraph();
 }
 
 
-Paragraph const & DocumentIterator::paragraph() const
+Paragraph const & DocIterator::paragraph() const
 {
 	BOOST_ASSERT(inTexted());
 	return top().paragraph();
 }
 
 
-Row & DocumentIterator::textRow()
+Row & DocIterator::textRow()
 {
 	return *paragraph().getRow(pos());
 }
 
 
-Row const & DocumentIterator::textRow() const
+Row const & DocIterator::textRow() const
 {
 	return *paragraph().getRow(pos());
 }
 
 
-DocumentIterator::par_type DocumentIterator::lastpar() const
+DocIterator::par_type DocIterator::lastpar() const
 {
 	return inMathed() ? 0 : text()->paragraphs().size() - 1;
 }
 
 
-DocumentIterator::pos_type DocumentIterator::lastpos() const
+DocIterator::pos_type DocIterator::lastpos() const
 {
 	return inMathed() ? cell().size() : paragraph().size();
 }
 
 
-DocumentIterator::row_type DocumentIterator::crow() const
+DocIterator::row_type DocIterator::crow() const
 {
 	return paragraph().row(pos());
 }
 
 
-DocumentIterator::row_type DocumentIterator::lastcrow() const
+DocIterator::row_type DocIterator::lastcrow() const
 {
 	return paragraph().rows.size();
 }
 
 
-DocumentIterator::idx_type DocumentIterator::lastidx() const
+DocIterator::idx_type DocIterator::lastidx() const
 {
 	return top().lastidx();
 }
 
 
-size_t DocumentIterator::nargs() const
+size_t DocIterator::nargs() const
 {
 	// assume 1x1 grid for main text
 	return top().nargs();
 }
 
 
-size_t DocumentIterator::ncols() const
+size_t DocIterator::ncols() const
 {
 	// assume 1x1 grid for main text
 	return top().ncols();
 }
 
 
-size_t DocumentIterator::nrows() const
+size_t DocIterator::nrows() const
 {
 	// assume 1x1 grid for main text
 	return top().nrows();
 }
 
 
-DocumentIterator::row_type DocumentIterator::row() const
+DocIterator::row_type DocIterator::row() const
 {
 	return top().row();
 }
 
 
-DocumentIterator::col_type DocumentIterator::col() const
+DocIterator::col_type DocIterator::col() const
 {
 	return top().col();
 }
 
 
-MathArray const & DocumentIterator::cell() const
+MathArray const & DocIterator::cell() const
 {
 	BOOST_ASSERT(inMathed());
 	return top().cell();
 }
 
 
-MathArray & DocumentIterator::cell()
+MathArray & DocIterator::cell()
 {
 	BOOST_ASSERT(inMathed());
 	return top().cell();
 }
 
 
-bool DocumentIterator::inMathed() const
+bool DocIterator::inMathed() const
 {
 	return !empty() && inset().inMathed();
 }
 
 
-bool DocumentIterator::inTexted() const
+bool DocIterator::inTexted() const
 {
 	return !empty() && !inset().inMathed();
 }
 
 
-LyXText * DocumentIterator::innerText() const
+LyXText * DocIterator::innerText() const
 {
 	BOOST_ASSERT(!empty());
 	// go up until first non-0 text is hit
@@ -223,7 +254,7 @@ LyXText * DocumentIterator::innerText() const
 }
 
 
-InsetBase * DocumentIterator::innerInsetOfType(int code) const
+InsetBase * DocIterator::innerInsetOfType(int code) const
 {
 	for (int i = size() - 1; i >= 0; --i)
 		if (operator[](i).inset_->lyxCode() == code)
@@ -232,8 +263,14 @@ InsetBase * DocumentIterator::innerInsetOfType(int code) const
 }
 
 
-void DocumentIterator::forwardPos()
+void DocIterator::forwardPos()
 {
+	//this dog bites his tail
+	if (empty()) {
+		push_back(CursorSlice(*inset_));
+		return;
+	}
+
 	CursorSlice & top = back();
 	//lyxerr << "XXX\n" << *this << endl;
 
@@ -294,78 +331,87 @@ void DocumentIterator::forwardPos()
 }
 
 
-void DocumentIterator::forwardChar()
+void DocIterator::forwardPar()
+{
+	forwardPos();
+	while (!empty() && (!inTexted() || pos() != 0))
+		forwardPos();
+}
+
+
+void DocIterator::forwardChar()
 {
-	forwardPos(); 
+	forwardPos();
 	while (size() != 0 && pos() == lastpos())
 		forwardPos();
 }
 
 
-void DocumentIterator::backwardChar()
+void DocIterator::forwardInset()
 {
-	lyxerr << "not implemented" << endl;
-	BOOST_ASSERT(false);
+	forwardPos();
+	while (size() != 0 && (pos() == lastpos() || nextInset() == 0))
+		forwardPos();
 }
 
 
-void DocumentIterator::forwardPar()
+void DocIterator::backwardChar()
 {
-	CursorSlice & top = back();
-	lyxerr << "XXX " << *this << endl;
+	backwardPos();
+	while (size() != 0 && pos() == lastpos())
+		backwardPos();
+}
 
-	// move into an inset to the right if possible
-	InsetBase * n = 0;
-	if (top.pos() != lastpos()) {
-		// this is impossible for pos() == size()
-		if (inMathed()) {
-			n = (top.cell().begin() + top.pos())->nucleus();
-		} else {
-			if (paragraph().isInset(top.pos()))
-				n = paragraph().getInset(top.pos());
-		}
-	}
 
-	if (n && n->isActive()) {
-		lyxerr << "... descend" << endl;
-		push_back(CursorSlice(*n));
+void DocIterator::backwardPos()
+{
+	//this dog bites his tail
+	if (empty()) {
+		push_back(CursorSlice(*inset_));
+		back().idx() = lastidx();
+		back().par() = lastpar();
+		back().pos() = lastpos();
 		return;
 	}
 
-	// otherwise move on one cell back if possible
-	if (top.pos() < lastpos()) {
-		lyxerr << "... next pos" << endl;
-		++top.pos();
-		return;
-	}
+	CursorSlice & top = back();
 
-	// otherwise move on one cell back if possible
-	if (top.par() < lastpar()) {
-		lyxerr << "... next par" << endl;
-		++top.par();
-		top.pos() = 0;
+	if (top.pos() != 0) {
+		--top.pos();
+	} else if (top.par() != 0) {
+		--top.par();
+		top.pos() = lastpos();
+		return;
+	} else if (top.idx() != 0) {
+		--top.idx();
+		top.par() = lastpar();
+		top.pos() = lastpos();
+		return;
+	} else {
+		pop_back();
 		return;
 	}
 
-	// otherwise try to move on one cell if possible
-	while (top.idx() < top.lastidx()) {
-		lyxerr << "... next idx" 
-			<< " was: " << top.idx() << " max: " << top.lastidx() << endl;
-		++top.idx();
-		top.par() = 0;
-		top.pos() = 0;
-		return;
+	// move into an inset to the left if possible
+	InsetBase * n = 0;
+
+	if (inMathed()) {
+		n = (top.cell().begin() + top.pos())->nucleus();
+	} else {
+		if (paragraph().isInset(top.pos()))
+			n = paragraph().getInset(top.pos());
 	}
 
-	// otherwise leave inset an jump over inset as a whole
-	pop_back();
-	// 'top' is invalid now...
-	if (size())
-		++back().pos();
+	if (n && n->isActive()) {
+		push_back(CursorSlice(*n));
+		back().idx() = lastidx();
+		back().par() = lastpar();
+		back().pos() = lastpos();
+	}
 }
 
 
-std::ostream & operator<<(std::ostream & os, DocumentIterator const & dit)
+std::ostream & operator<<(std::ostream & os, DocIterator const & dit)
 {
 	for (size_t i = 0, n = dit.size(); i != n; ++i)
 		os << " " << dit.operator[](i) << "\n";
@@ -376,7 +422,7 @@ std::ostream & operator<<(std::ostream & os, DocumentIterator const & dit)
 
 ///////////////////////////////////////////////////////
 
-StableDocumentIterator::StableDocumentIterator(const DocumentIterator & dit)
+StableDocIterator::StableDocIterator(const DocIterator & dit)
 {
 	data_ = dit;
 	for (size_t i = 0, n = data_.size(); i != n; ++i)
@@ -384,12 +430,12 @@ StableDocumentIterator::StableDocumentIterator(const DocumentIterator & dit)
 }
 
 
-DocumentIterator
-StableDocumentIterator::asDocumentIterator(InsetBase * inset) const
+DocIterator
+StableDocIterator::asDocIterator(InsetBase * inset) const
 {
 	// this function re-creates the cache of inset pointers
 	//lyxerr << "converting:\n" << *this << endl;
-	DocumentIterator dit;
+	DocIterator dit = DocIterator(*inset);
 	for (size_t i = 0, n = data_.size(); i != n; ++i) {
 		dit.push_back(data_[i]);
 		dit.back().inset_ = inset;
@@ -401,10 +447,9 @@ StableDocumentIterator::asDocumentIterator(InsetBase * inset) const
 }
 
 
-std::ostream & operator<<(std::ostream & os, StableDocumentIterator const & dit)
+std::ostream & operator<<(std::ostream & os, StableDocIterator const & dit)
 {
 	for (size_t i = 0, n = dit.data_.size(); i != n; ++i)
 		os << " " << dit.data_[i] << "\n";
 	return os;
 }
-