#ifndef TEXROW_H
#define TEXROW_H
-#include "support/types.h"
#include "support/debug.h"
+#include "support/docstring.h"
+#include "support/types.h"
#include <vector>
namespace lyx {
-class LyXErr;
+class Buffer;
class Cursor;
class CursorSlice;
class DocIterator;
class docstring_list;
+class FuncRequest;
/// types for cells and math insets
typedef void const * uid_type;
typedef size_t idx_type;
-/// an individual par id/pos <=> row mapping
-struct TextEntry { int id; int pos; };
-
-/// an individual math id/cell <=> row mapping
-struct MathEntry { uid_type id; idx_type cell; };
-
-/// a container for passing entries around
-struct RowEntry {
- bool is_math;// true iff the union is a math
- union {
- struct TextEntry text;
- struct MathEntry math;
- };
-};
-
-
/// Represents the correspondence between paragraphs and the generated
/// LaTeX file
class TexRow {
public:
- // For each row we store a list of one special TextEntry and several
- // RowEntries. (The order is important.) We only want one text entry
- // because we do not want to store every position in the lyx file. On the
- // other hand we want to record all math and table cells positions for
- // enough precision. Usually the count of cells is easier to handle.
- class RowEntryList : public std::vector<RowEntry> {
- public:
- RowEntryList() : std::vector<RowEntry>(), text_entry_(-1) {}
-
- // returns true if the row entry will appear in the row entry list
- bool addEntry(RowEntry const &);
-
- // the row entry will appear in the row entry list, but it never counts
- // as a proper text entry.
- void forceAddEntry(RowEntry const &);
-
- // returns the TextEntry or TexRow::text_none if none
- TextEntry getTextEntry() const;
-
- // returns the first entry, or TexRow::row_none if none
- RowEntry entry() const;
-
- // appends a row
- void append(RowEntryList const &);
+ /// We begin with defining the types of row information we are tracking
+ ///
- private:
- size_t text_entry_;
+ /// type of row entries
+ enum RowType {
+ text_entry,
+ math_entry,
+ begin_document
};
- /// Returns true if RowEntry is devoid of information
- static bool isNone(RowEntry const &);
- static const TextEntry text_none;
- static const RowEntry row_none;
+ /// an individual par id/pos <=> row mapping
+ struct TextEntry { int id; pos_type pos; };
- /// Returns true if TextEntry is devoid of information
- static bool isNone(TextEntry const &);
+ /// an individual math id/cell <=> row mapping
+ struct MathEntry { uid_type id; idx_type cell; };
- /// Converts a CursorSlice into a RowEntry
- static RowEntry rowEntryFromCursorSlice(CursorSlice const & slice);
+ /// a container for passing entries around
+ struct RowEntry {
+ RowType type;
+ union {
+ struct TextEntry text;// iff the type is text_entry
+ struct MathEntry math;// iff the type is row_entry
+ struct {} begindocument;// iff the type is begin_document
+ };
+ };
/// Encapsulates the paragraph and position for later use
- static RowEntry textEntry(int id, int pos);
-
+ static RowEntry textEntry(int id, pos_type pos);
/// Encapsulates a cell and position for later use
static RowEntry mathEntry(uid_type id, idx_type cell);
+ /// Denotes the beginning of the document
+ static RowEntry beginDocument();
- /// true iff same paragraph or math inset
- static bool sameParOrInsetMath(RowEntry const &, RowEntry const &);
+ /// Converts a CursorSlice into a RowEntry
+ static RowEntry rowEntryFromCursorSlice(CursorSlice const & slice);
- /// computes the distance in pos or cell index
- /// assumes it is the sameParOrInsetMath
- static int comparePos(RowEntry const & entry1, RowEntry const & entry2);
+ static const TextEntry text_none;
+ static const RowEntry row_none;
+ /// Returns true if RowEntry is devoid of information
+ static bool isNone(RowEntry entry);
+ /// Returns true if TextEntry is devoid of information
+ static bool isNone(TextEntry entry);
- /// for debugging purposes
- static docstring asString(RowEntry const &);
+private:
+ /// id/pos correspondence for a single row
+ class RowEntryList;
+ /// container of id/pos <=> row mapping
+ /// invariant: in any enabled_ TexRow, rowlist_ will contain at least one
+ /// Row (the current row)
+ typedef std::vector<RowEntryList> RowList;
///
- TexRow(bool enable = true)
- : current_row_(RowEntryList()), enabled_(enable) {}
+ RowList rowlist_;
+ ///
+ RowEntryList & currentRow();
- /// Clears structure. Set enable to false if texrow is not needed, to avoid
- /// computing TexRow when it is going to be immediately discarded.
- void reset(bool enable = true);
+ ///
+ class RowListIterator;
+ ///
+ RowListIterator begin() const;
+ ///
+ RowListIterator end() const;
+public:
+ ///
+ TexRow();
+
+#if !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
+ /// Copy can be expensive and is not usually useful for TexRow.
+ /// Force explicit copy, prefer move instead. This also prevents
+ /// move()s from being converted into copy silently.
+ explicit TexRow(TexRow const & other) = default;
+ TexRow(TexRow && other) = default;
+ TexRow & operator=(TexRow const & other) = default;
+ TexRow & operator=(TexRow && other) = default;
+# else
+ //for gcc 4.6, nothing to do: it's enough to disable implicit copy during
+ // dev with more recent versions of gcc.
+#endif
+
+ /// Clears structure.
+ void reset();
+
+ /// for debugging purposes
+ static docstring asString(RowEntry entry);
/// Defines the row information for the current line
/// returns true if this entry will appear on the current row
bool start(RowEntry entry);
-
/// Defines the paragraph and position for the current line
/// returns true if this entry will appear on the current row
- bool start(int id, int pos);
-
+ bool start(int id, pos_type pos);
/// Defines a cell and position for the current line. Always appear in the
/// current row.
void startMath(uid_type id, idx_type cell);
-
/// Defines the paragraph for the current cell-like inset. Always appears
/// in the current row like a math cell, but is detached from the normal
/// text flow. Note: since the cell idx is not recorded it does not work as
/// well as for math grids; if we were to do that properly we would need to
/// access the id of the parent Tabular inset from the CursorSlice.
- void forceStart(int id, int pos);
+ void forceStart(int id, pos_type pos);
/// Insert node when line is completed
void newline();
-
/// Insert multiple nodes when zero or more lines are completed
- void newlines(int num_lines);
+ void newlines(size_t num_lines);
+
+ /**
+ * getEntriesFromRow - find pids and position for a given row
+ * This is the main algorithm behind reverse-search.
+ * @param row number to find
+ * @return a pair of TextEntry denoting the start and end of the position.
+ * The TextEntry values can be isNone(). If no row is found then the first
+ * value isNone().
+ */
+ std::pair<TextEntry,TextEntry> getEntriesFromRow(int row) const;
+
+ /**
+ * getDocIteratorFromEntries - find pids and positions for a given row
+ * @param buffer where to look
+ * @return a pair of DocIterators denoting the start and end of the
+ * position. The DocIterators can be invalid. The starting DocIterator
+ * being invalid means that no location was found. Note: there is no
+ * guarantee that the DocIterators are in the same inset or even at the
+ * same depth.
+ */
+ static std::pair<DocIterator, DocIterator> getDocIteratorsFromEntries(
+ TextEntry start,
+ TextEntry end,
+ Buffer const & buf);
- /// Call when code generation is complete
- void finalize();
+ // A FuncRequest to select from start to end
+ static FuncRequest goToFunc(TextEntry start, TextEntry end);
+ // A FuncRequest to select a row
+ FuncRequest goToFuncFromRow(int const row) const;
/**
- * getIdFromRow - find pid and position for a given row
- * @param row row number to find
- * @param id set to id if found
- * @param pos set to paragraph position if found
- * @return true if found, false otherwise
- *
- * If the row could not be found, pos is set to zero and
- * id is set to -1
+ * getDocIteratorFromRow - find pids and positions for a given row
+ * @param row number to find
+ * @param buffer where to look
+ * @return a pair of DocIterators as above.
*/
- bool getIdFromRow(int row, int & id, int & pos) const;
+ std::pair<DocIterator, DocIterator> getDocIteratorsFromRow(
+ int row,
+ Buffer const & buf) const;
/// Finds the best pair of rows for dit
/// returns (-1,-1) if not found.
+ /// This is the main algorithm behind forward-search.
std::pair<int,int> rowFromDocIterator(DocIterator const & dit) const;
/// Finds the best pair of rows for cursor, taking the selection into
/// account
/// returns (-1,-1) if not found.
std::pair<int,int> rowFromCursor(Cursor const & dit) const;
-
+
/// Returns the number of rows contained
- int rows() const { return rowlist_.size(); }
+ size_t rows() const;
+ /// Fill or trim to reach the row count \param r
+ void setRows(size_t r);
/// appends texrow. the final line of this is merged with the first line of
/// texrow.
- void append(TexRow const & texrow);
+ void append(TexRow texrow);
/// for debugging purpose
void prepend(docstring_list &) const;
private:
- typedef std::vector<RowEntryList> RowList;
+ /// true iff same paragraph or math inset or begin_document
+ static bool sameParOrInsetMath(RowEntry entry1, RowEntry entry2);
+ /// computes the distance in pos or cell index
+ /// assumes it is the sameParOrInsetMath
+ static int comparePos(RowEntry entry1, RowEntry entry2);
+
+};
+
+
+/// TexString : dumb struct to pass around docstrings with TexRow information.
+/// They are best created using otexstringstream.
+/// They can be output to otexrowstreams and otexstreams.
+/// A valid TexString has as many newlines in str as in texrow. Be careful not
+/// to introduce a mismatch between the line and the row counts, as this will
+/// assert in devel mode when outputting to a otexstream.
+struct TexString {
///
- class RowListIterator;
+ docstring str;
///
- RowListIterator begin() const;
+ TexRow texrow;
+#if !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
+ /// Copy can be expensive and is not usually useful for TexString.
+ /// Force explicit copy, prefer move instead. This also prevents
+ /// move()s from being converted into copy silently.
+ explicit TexString(TexString const &) = default;
+ TexString(TexString && other) = default;
+ TexString & operator=(TexString const & other) = default;
+ TexString & operator=(TexString && other) = default;
+# else
+ //for gcc 4.6, nothing to do: it's enough to disable implicit copy during
+ // dev with more recent versions of gcc.
+#endif
+ /// Empty TexString
+ TexString() = default;
+ /// Texstring containing str and TexRow with enough lines which are empty
+ explicit TexString(docstring str);
+ /// Texstring containing str and texrow. Must be valid.
+ TexString(docstring str, TexRow texrow);
+ /// Ensure that the string and the TexRow have as many newlines.
+ void validate();
+};
+
+
+// Standard container needs a complete type
+class TexRow::RowEntryList {
+ // For each row we store a list of one special TextEntry and several
+ // RowEntries. (The order is important.) We only want one text entry
+ // because we do not want to store every position in the lyx file. On the
+ // other hand we want to record all math and table cells positions for
+ // enough precision. Usually the count of cells is easier to handle.
+ // The RowEntries are used for forward-search and the code preview pane.
+ std::vector<RowEntry> v_;
+ // The TextEntry is currently used for reverse-search and the error
+ // reporting dialog. Once the latter are adapted to rely on the more precise
+ // RowEntries above, it can be removed.
+ TextEntry text_entry_;
+
+public:
+ typedef std::vector<RowEntry>::iterator iterator;
+ iterator begin() { return v_.begin(); }
+ iterator end() { return v_.end(); }
///
- RowListIterator end() const;
- /// container of id/pos <=> row mapping
- RowList rowlist_;
- /// Entry of current line
- RowEntryList current_row_;
- ///
- bool enabled_;
+ typedef std::vector<RowEntry>::const_iterator const_iterator;
+ const_iterator begin() const { return v_.cbegin(); }
+ const_iterator end() const { return v_.cend(); }
+ ///
+ RowEntryList() : text_entry_(TexRow::text_none) {}
+
+ // returns true if the row entry will appear in the row entry list
+ bool addEntry(RowEntry entry);
+
+ // the row entry will appear in the row entry list, but it never counts
+ // as a proper text entry.
+ void forceAddEntry(RowEntry entry);
+
+ // returns the TextEntry or TexRow::text_none if none
+ TextEntry getTextEntry() const;
+
+ // appends a row
+ void append(RowEntryList row);
};
-bool operator==(RowEntry const &, RowEntry const &);
-LyXErr & operator<<(LyXErr &, TexRow &);
+bool operator==(TexRow::RowEntry entry1, TexRow::RowEntry entry2);
} // namespace lyx
projects / lyx.git / blobdiff