#include <vector>
#include <iosfwd>
+
+namespace lyx {
+
class LyXText;
class MathAtom;
class Paragraph;
-class Row;
-
// only needed for gcc 2.95, remove when support terminated
public:
/// type for cell number in inset
typedef CursorSlice::idx_type idx_type;
- /// type for paragraph numbers positions within a cell
- typedef CursorSlice::pit_type pit_type;
- /// type for cursor positions within a cell
- typedef CursorSlice::pos_type pos_type;
/// type for row indices
typedef CursorSlice::row_type row_type;
/// type for col indices
///
explicit DocIterator(InsetBase & inset);
- CursorSlice const & operator[](size_t i) const {
- return slices_[i];
- }
-
- CursorSlice & operator[](size_t i) {
- return slices_[i];
- }
-
- // What is the point of this function?
+ /// access slice at position \p i
+ CursorSlice const & operator[](size_t i) const { return slices_[i]; }
+ /// access slice at position \p i
+ CursorSlice & operator[](size_t i) { return slices_[i]; }
+ /// chop a few slices from the iterator
void resize(size_t i) { slices_.resize(i); }
/// is the iterator valid?
/// is this iterator invalid?
bool operator!() const { return empty(); }
+ /// does this iterator have any content?
bool empty() const { return slices_.empty(); }
//
CursorSlice const & top() const { return slices_.back(); }
/// access to outermost slice
CursorSlice & bottom() { return slices_.front(); }
- /// access to outermost slicetip
+ /// access to outermost slice
CursorSlice const & bottom() const { return slices_.front(); }
/// how many nested insets do we have?
size_t depth() const { return slices_.size(); }
idx_type idx() const { return top().idx(); }
/// return the cell of the inset this cursor is in
idx_type & idx() { return top().idx(); }
- ///
- void idxSave() { top().idxSave(); }
- ///
- void idxLoad() { top().idxLoad(); }
/// return the last possible cell in this inset
idx_type lastidx() const;
/// return the paragraph this cursor is in
InsetBase * prevInset();
/// the inset just in front of the cursor
InsetBase const * prevInset() const;
+ ///
+ bool boundary() const { return boundary_; }
+ ///
+ void boundary(bool b) { boundary_ = b; }
- /// are we in mathed?
- bool inMathed() const;
- /// are we in texted?
- bool inTexted() const;
+ // the two methods below have been inlined out because of
+ // profiling results under linux when opening a document.
+ /// are we in mathed?.
+ bool inMathed() const
+ { return !empty() && inset().inMathed(); }
+ /// are we in texted?.
+ bool inTexted() const
+ { return !empty() && !inset().inMathed(); }
//
// math-specific part
//
// text-specific part
//
- /// see comment for boundary_ below
- bool boundary() const { return top().boundary(); }
- /// see comment for boundary_ below
- bool & boundary() { return top().boundary(); }
/// the paragraph we're in
Paragraph & paragraph();
/// the paragraph we're in
Paragraph const & paragraph() const;
- /// the row in the paragraph we're in
- Row & textRow();
- /// the row in the paragraph we're in
- Row const & textRow() const;
///
LyXText * text();
///
LyXText const * text() const;
+ /// the containing inset or the cell, respectively
+ InsetBase * realInset() const;
///
InsetBase * innerInsetOfType(int code) const;
///
//
/// move on one logical position, do not descend into nested insets
void forwardPosNoDescend();
- /// move on one logical position, descend into nested insets
- void forwardPos();
+ /**
+ * move on one logical position, descend into nested insets
+ * skip collapsed insets if \p ignorecollapsed is true
+ */
+ void forwardPos(bool ignorecollapsed = false);
/// move on one physical character or inset
void forwardChar();
/// move on one paragraph
/// move backward one cell
void backwardIdx();
/// move backward one inset
- void backwardInset();
+ /// FIXME: This is not implemented!
+ //void backwardInset();
/// are we some 'extension' (i.e. deeper nested) of the given iterator
bool hasPart(DocIterator const & it) const;
/// output
friend std::ostream &
operator<<(std::ostream & os, DocIterator const & cur);
+ ///
friend bool operator==(DocIterator const &, DocIterator const &);
+ ///
friend class StableDocIterator;
-protected:
+//protected:
+ ///
void clear() { slices_.clear(); }
- void push_back(CursorSlice const & sl) {
- slices_.push_back(sl);
- }
- void pop_back() {
- slices_.pop_back();
- }
+ ///
+ void push_back(CursorSlice const & sl) { slices_.push_back(sl); }
+ ///
+ void pop_back() { slices_.pop_back(); }
+ /// recompute the inset parts of the cursor from the document data
+ void updateInsets(InsetBase * inset);
+
private:
+ /**
+ * When the cursor position is i, is the cursor after the i-th char
+ * or before the i+1-th char ? Normally, these two interpretations are
+ * equivalent, except when the fonts of the i-th and i+1-th char
+ * differ.
+ * We use boundary_ to distinguish between the two options:
+ * If boundary_=true, then the cursor is after the i-th char
+ * and if boundary_=false, then the cursor is before the i+1-th char.
+ *
+ * We currently use the boundary only when the language direction of
+ * the i-th char is different than the one of the i+1-th char.
+ * In this case it is important to distinguish between the two
+ * cursor interpretations, in order to give a reasonable behavior to
+ * the user.
+ */
+ bool boundary_;
+ ///
std::vector<CursorSlice> const & internalData() const {
return slices_;
}
+ ///
std::vector<CursorSlice> slices_;
+ ///
InsetBase * inset_;
};
// The difference to a ('non stable') DocIterator is the removed
-// (overwritte by 0...) part of the CursorSlice data items. So this thing
+// (overwritten by 0...) part of the CursorSlice data items. So this thing
// is suitable for external storage, but not for iteration as such.
class StableDocIterator {
DocIterator asDocIterator(InsetBase * start) const;
///
size_t size() const { return data_.size(); }
+ /// return the position within the paragraph
+ pos_type pos() const { return data_.back().pos(); }
+ /// return the position within the paragraph
+ pos_type & pos() { return data_.back().pos(); }
///
friend std::ostream &
operator<<(std::ostream & os, StableDocIterator const & cur);
std::vector<CursorSlice> data_;
};
+
+} // namespace lyx
+
#endif