* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author André Pönitz
+ * \author André Pönitz
*
* Full author contact details are available in file CREDITS.
*/
#include "CursorSlice.h"
#include <vector>
-#include <iosfwd>
-
+#include <algorithm>
namespace lyx {
-class Text;
+class DocIterator;
+class Encoding;
+class LyXErr;
class MathAtom;
class Paragraph;
+class Text;
+class InsetIterator;
+class FontSpan;
-
-// 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;
-}
+DocIterator doc_iterator_begin(Buffer const * buf, Inset const * inset = 0);
+DocIterator doc_iterator_end(Buffer const * buf, Inset const * inset = 0);
-// The public inheritance should go in favour of a suitable data member
-// (or maybe private inheritance) at some point of time.
-class DocIterator // : public std::vector<CursorSlice>
+class DocIterator
{
public:
/// type for cell number in inset
///
DocIterator();
///
- explicit DocIterator(Inset & inset);
+ explicit DocIterator(Buffer *buf);
+
+ /// access to owning buffer
+ Buffer * buffer() const { return buffer_; }
+ /// access to owning buffer
+ void setBuffer(Buffer * buf) { buffer_ = buf; }
+
+ /// Clone this for given \p buffer.
+ /// \p buffer must be a clone of buffer_.
+ DocIterator clone(Buffer * buffer) const;
/// access slice at position \p i
CursorSlice const & operator[](size_t i) const { return slices_[i]; }
void resize(size_t i) { slices_.resize(i); }
/// is the iterator valid?
- operator const void*() const { return empty() ? 0 : this; }
- /// is this iterator invalid?
- bool operator!() const { return empty(); }
+ explicit operator bool() const { return !empty(); }
/// does this iterator have any content?
bool empty() const { return slices_.empty(); }
+ /// is this the end position?
+ bool atEnd() const { return slices_.empty(); }
+ /// is this the last possible position?
+ bool atLastPos() const { return pit() == lastpit() && pos() == lastpos(); }
+
+ /// checks the cursor slices for disabled spell checker insets
+ bool allowSpellCheck() const;
//
// access to slice at tip
/// are we in texted?.
bool inTexted() const
{ return !empty() && !inset().inMathed(); }
+ /// are we in regexp-mode ?
+ bool inRegexped() const;
//
// math-specific part
Paragraph & innerParagraph() const;
/// return the inner text slice.
CursorSlice const & innerTextSlice() const;
+ // convert a DocIterator into an argument to LFUN_PARAGRAPH_GOTO
+ docstring paragraphGotoArgument() const;
+ /// returns a DocIterator for the containing text inset
+ DocIterator getInnerText() const;
+ /// the first and last positions of a word at top cursor slice
+ /// \warning only works within text!
+ FontSpan locateWord(word_location const loc) const;
///
Text * text() const;
/// the containing inset or the cell, respectively
//
// elementary moving
//
+ /// move one step backwards
+ bool posBackward();
+ /// move one step forward
+ bool posForward();
/**
* move on one logical position, descend into nested insets
- * skip collapsed insets if \p ignorecollapsed is true
+ * including collapsed insets
*/
- void forwardPos(bool ignorecollapsed = false);
+ void forwardPos();
+ /**
+ * move on one logical position, descend into nested insets
+ * skip collapsed insets
+ */
+ void forwardPosIgnoreCollapsed();
/// move on one physical character or inset
void forwardChar();
/// move on one paragraph
/// move backward one paragraph
void backwardPar();
/// move backward one inset
- /// FIXME: This is not implemented!
+ /// not used currently, uncomment if you need it
//void backwardInset();
/// are we some 'extension' (i.e. deeper nested) of the given iterator
/// 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 &);
/// fix DocIterator in circumstances that should never happen.
/// \return true if the DocIterator was fixed.
bool fixIfBroken();
+ /// Repopulate the slices insets from bottom to top. Useful
+ /// for stable iterators or Undo data.
+ void sanitize();
+
+ /// find index of CursorSlice with &cell() == &cell (or -1 if not found)
+ int find(MathData const & cell) const;
+ /// find index of CursorSlice with inset() == inset (or -1 of not found)
+ int find(Inset const * inset) const;
+ /// cut off CursorSlices with index > above and store cut off slices in cut.
+ void cutOff(int above, std::vector<CursorSlice> & cut);
+ /// cut off CursorSlices with index > above
+ void cutOff(int 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);
+
+ ///
+ Encoding const * getEncoding() const;
private:
+ friend class InsetIterator;
+ friend DocIterator doc_iterator_begin(Buffer const * buf, Inset const * inset);
+ friend DocIterator doc_iterator_end(Buffer const * buf, Inset const * inset);
+ ///
+ explicit DocIterator(Buffer * buf, Inset * inset);
/**
- * 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.
+ * Normally, when the cursor is at position i, it is painted *before*
+ * the character at position i. However, what if we want the cursor
+ * painted *after* position i? That's what boundary_ is for: if
+ * boundary_==true, the cursor is painted *after* position i-1, instead
+ * of before position i.
*
- * 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.
+ * Note 1: Usually, after i-1 or before i are actually the same place!
+ * However, this is not the case when i-1 and i are not painted
+ * contiguously, and in these cases we sometimes do want to have control
+ * over whether to paint before i or after i-1.
+ * Some concrete examples of where this happens:
+ * a. i-1 at the end of one row, i at the beginning of next row
+ * b. in bidi text, at transitions between RTL and LTR or vice versa
+ *
+ * Note 2: Why i and i-1? Why, if boundary_==false means: *before* i,
+ * couldn't boundary_==true mean: *after* i?
+ * Well, the reason is this: cursor position is not used only for
+ * painting the cursor, but it also affects other things, for example:
+ * where the next insertion will be placed (it is inserted at the current
+ * position, pushing anything at the current position and beyond forward).
+ * Now, when the current position is i and boundary_==true, insertion would
+ * happen *before* i. If the cursor, however, were painted *after* i, that
+ * would be very unnatural...
*/
bool boundary_;
///
- std::vector<CursorSlice> const & internalData() const {
- return slices_;
- }
+ std::vector<CursorSlice> const & internalData() const { return slices_; }
///
std::vector<CursorSlice> slices_;
///
Inset * inset_;
+ ///
+ Buffer * buffer_;
};
-DocIterator doc_iterator_begin(Inset & inset);
-DocIterator doc_iterator_end(Inset & inset);
+inline bool operator==(DocIterator const & di1, DocIterator const & di2)
+{
+ return di1.slices_ == di2.slices_;
+}
+
+
+inline bool operator!=(DocIterator const & di1, DocIterator const & di2)
+{
+ return !(di1 == di2);
+}
inline
-bool operator==(DocIterator const & di1, DocIterator const & di2)
+bool operator<(DocIterator const & p, DocIterator const & q)
{
- return di1.slices_ == di2.slices_;
+ 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 & di1, DocIterator const & di2)
+bool operator>(DocIterator const & p, DocIterator const & q)
{
- return !(di1 == di2);
+ return q < p;
+}
+
+
+inline
+bool operator<=(DocIterator const & p, DocIterator const & q)
+{
+ return !(q < p);
+}
+
+
+inline
+bool operator>=(DocIterator const & p, DocIterator const & q)
+{
+ return !(p < q);
}
// (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 {
+class StableDocIterator
+{
public:
///
StableDocIterator() {}
/// non-explicit intended
StableDocIterator(const DocIterator & it);
///
- DocIterator asDocIterator(Inset * start) const;
+ DocIterator asDocIterator(Buffer * buf) const;
///
size_t size() const { return data_.size(); }
/// return the position within the paragraph
std::vector<CursorSlice> data_;
};
-
} // namespace lyx
-#endif
+#endif // DOCITERATOR_H
projects / lyx.git / blobdiff