X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTexRow.h;h=e40867d7b1416f113ca41d448655729bc1ced685;hb=6a21ec854b356fbbc89aaf99b2a23e4c3de4aca6;hp=7468386be4edfbef55b3d2af10c6d69602085e1d;hpb=73d3816e0f2083a2dc53d744f32d206a153556be;p=lyx.git diff --git a/src/TexRow.h b/src/TexRow.h index 7468386be4..e40867d7b1 100644 --- a/src/TexRow.h +++ b/src/TexRow.h @@ -12,25 +12,35 @@ * Full author contact details are available in file CREDITS. */ +/* Note about debugging options: + * + * When compiled in devel mode and run with the option -dbg latex, two ways + * of debugging TexRow are available: + * + * 1. The source view panel prepends the full TexRow information to the LaTeX + * output. + * + * 2. Clicking on any line in the source view moves the buffer to the location + * recognised by TexRow. + * + */ + #ifndef TEXROW_H #define TEXROW_H +#include "support/docstring.h" #include "support/types.h" -#include "support/debug.h" #include namespace lyx { -class LyXErr; +class Buffer; class Cursor; class CursorSlice; class DocIterator; class docstring_list; - -/// types for cells and math insets -typedef void const * uid_type; -typedef size_t idx_type; +class FuncRequest; /// Represents the correspondence between paragraphs and the generated @@ -38,145 +48,248 @@ typedef size_t idx_type; class TexRow { public: + /// We begin with defining the types of row information we are tracking + /// + + /// type of row entries + enum RowType { + text_entry, + math_entry, + begin_document + }; + /// an individual par id/pos <=> row mapping - struct TextEntry { int id; int pos; }; + struct TextEntry { int id; pos_type 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 + RowType type; union { - struct TextEntry text; - struct MathEntry math; + 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 }; }; - // For each row we store a list of one TextEntry and several - // MathEntries. (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 cells positions for enough - // precision. Usually the count of math cells is easier to handle. - class RowEntryList : public std::vector { - public: - RowEntryList() : std::vector(), text_entry_(-1) {} - - // returns true if the row entry will appear in the row entry list - bool addEntry(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; + /// Encapsulates the paragraph and position for later use + 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(); - private: - size_t text_entry_; - }; + /// Converts a CursorSlice into a RowEntry + static RowEntry rowEntryFromCursorSlice(CursorSlice const & slice); - /// Returns true if RowEntry is devoid of information - static bool isNone(RowEntry const &); 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 const &); + static bool isNone(TextEntry entry); - /// Converts a CursorSlice into a RowEntry - static RowEntry rowEntryFromCursorSlice(CursorSlice const & slice); +private: + /// id/pos correspondence for a single row + class RowEntryList; - /// Encapsulates the paragraph and position for later use - static RowEntry textEntry(int id, int pos); + /// container of id/pos <=> row mapping + /// invariant: in any enabled_ TexRow, rowlist_ will contain at least one + /// Row (the current row) + typedef std::vector RowList; + /// + RowList rowlist_; + /// + RowEntryList & currentRow(); - /// Encapsulates a cell and position for later use - static RowEntry mathEntry(uid_type id, idx_type cell); + /// + class RowListIterator; + /// + RowListIterator begin() const; + /// + RowListIterator end() const; +public: + /// + TexRow(); - /// true iff same paragraph or math inset - static bool sameParOrInsetMath(RowEntry const &, RowEntry const &); + /// 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; - /// computes the distance in pos or cell index - /// assumes it is the sameParOrInsetMath - static int comparePos(RowEntry const & entry1, RowEntry const & entry2); + /// Clears structure. + void reset(); /// for debugging purposes - static docstring asString(RowEntry const &); - - /// - TexRow(bool enable = true) - : current_row_(RowEntryList()), enabled_(enable) {} - - /// 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); + 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); - - /// Defines a cell and position for the current line - /// returns true if this entry will appear on the current row - bool startMath(uid_type id, idx_type cell); + 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, 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); - /// Call when code generation is complete - void finalize(); + /** + * 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 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 getDocIteratorsFromEntries( + TextEntry start, + TextEntry end, + Buffer const & buf); + + // 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 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 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 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 texrow); /// for debugging purpose void prepend(docstring_list &) const; private: - typedef std::vector 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; + /// 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; + /// 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 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::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::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==(TexRow::RowEntry const &, TexRow::RowEntry const &); -LyXErr & operator<<(LyXErr &, TexRow &); +bool operator==(TexRow::RowEntry entry1, TexRow::RowEntry entry2); } // namespace lyx