4 * This file is part of LyX, the document processor.
5 * Licence details can be found in the file COPYING.
7 * \author Matthias Ettrich
8 * \author Lars Gullik Bjønnes
10 * \author Guillaume Munch
12 * Full author contact details are available in file CREDITS.
15 /* Note about debugging options:
17 * When compiled in devel mode and run with the option -dbg latex, two ways
18 * of debugging TexRow are available:
20 * 1. The source view panel prepends the full TexRow information to the LaTeX
23 * 2. Clicking on any line in the source view moves the buffer to the location
24 * recognised by TexRow.
31 #include "support/debug.h"
32 #include "support/docstring.h"
33 #include "support/types.h"
46 /// types for cells and math insets
47 typedef void const * uid_type;
48 typedef size_t idx_type;
51 /// Represents the correspondence between paragraphs and the generated
56 /// We begin with defining the types of row information we are tracking
59 /// type of row entries
66 /// an individual par id/pos <=> row mapping
67 struct TextEntry { int id; pos_type pos; };
69 /// an individual math id/cell <=> row mapping
70 struct MathEntry { uid_type id; idx_type cell; };
72 /// a container for passing entries around
76 struct TextEntry text;// iff the type is text_entry
77 struct MathEntry math;// iff the type is row_entry
78 struct {} begindocument;// iff the type is begin_document
82 /// Encapsulates the paragraph and position for later use
83 static RowEntry textEntry(int id, pos_type pos);
84 /// Encapsulates a cell and position for later use
85 static RowEntry mathEntry(uid_type id, idx_type cell);
86 /// Denotes the beginning of the document
87 static RowEntry beginDocument();
89 /// Converts a CursorSlice into a RowEntry
90 static RowEntry rowEntryFromCursorSlice(CursorSlice const & slice);
92 static const TextEntry text_none;
93 static const RowEntry row_none;
94 /// Returns true if RowEntry is devoid of information
95 static bool isNone(RowEntry entry);
96 /// Returns true if TextEntry is devoid of information
97 static bool isNone(TextEntry entry);
100 /// id/pos correspondence for a single row
103 /// container of id/pos <=> row mapping
104 /// invariant: in any enabled_ TexRow, rowlist_ will contain at least one
105 /// Row (the current row)
106 typedef std::vector<RowEntryList> RowList;
110 RowEntryList & currentRow();
113 class RowListIterator;
115 RowListIterator begin() const;
117 RowListIterator end() const;
122 #if !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
123 /// Copy can be expensive and is not usually useful for TexRow.
124 /// Force explicit copy, prefer move instead. This also prevents
125 /// move()s from being converted into copy silently.
126 explicit TexRow(TexRow const & other) = default;
127 TexRow(TexRow && other) = default;
128 TexRow & operator=(TexRow const & other) = default;
129 TexRow & operator=(TexRow && other) = default;
131 //for gcc 4.6, nothing to do: it's enough to disable implicit copy during
132 // dev with more recent versions of gcc.
135 /// Clears structure.
138 /// for debugging purposes
139 static docstring asString(RowEntry entry);
141 /// Defines the row information for the current line
142 /// returns true if this entry will appear on the current row
143 bool start(RowEntry entry);
144 /// Defines the paragraph and position for the current line
145 /// returns true if this entry will appear on the current row
146 bool start(int id, pos_type pos);
147 /// Defines a cell and position for the current line. Always appear in the
149 void startMath(uid_type id, idx_type cell);
150 /// Defines the paragraph for the current cell-like inset. Always appears
151 /// in the current row like a math cell, but is detached from the normal
152 /// text flow. Note: since the cell idx is not recorded it does not work as
153 /// well as for math grids; if we were to do that properly we would need to
154 /// access the id of the parent Tabular inset from the CursorSlice.
155 void forceStart(int id, pos_type pos);
157 /// Insert node when line is completed
159 /// Insert multiple nodes when zero or more lines are completed
160 void newlines(size_t num_lines);
163 * getEntriesFromRow - find pids and position for a given row
164 * This is the main algorithm behind reverse-search.
165 * @param row number to find
166 * @return a pair of TextEntry denoting the start and end of the position.
167 * The TextEntry values can be isNone(). If no row is found then the first
170 std::pair<TextEntry,TextEntry> getEntriesFromRow(int row) const;
173 * getDocIteratorFromEntries - find pids and positions for a given row
174 * @param buffer where to look
175 * @return a pair of DocIterators denoting the start and end of the
176 * position. The DocIterators can be invalid. The starting DocIterator
177 * being invalid means that no location was found. Note: there is no
178 * guarantee that the DocIterators are in the same inset or even at the
181 static std::pair<DocIterator, DocIterator> getDocIteratorsFromEntries(
186 // A FuncRequest to select from start to end
187 static FuncRequest goToFunc(TextEntry start, TextEntry end);
188 // A FuncRequest to select a row
189 FuncRequest goToFuncFromRow(int const row) const;
192 * getDocIteratorFromRow - find pids and positions for a given row
193 * @param row number to find
194 * @param buffer where to look
195 * @return a pair of DocIterators as above.
197 std::pair<DocIterator, DocIterator> getDocIteratorsFromRow(
199 Buffer const & buf) const;
201 /// Finds the best pair of rows for dit
202 /// returns (-1,-1) if not found.
203 /// This is the main algorithm behind forward-search.
204 std::pair<int,int> rowFromDocIterator(DocIterator const & dit) const;
206 /// Finds the best pair of rows for cursor, taking the selection into
208 /// returns (-1,-1) if not found.
209 std::pair<int,int> rowFromCursor(Cursor const & dit) const;
211 /// Returns the number of rows contained
213 /// Fill or trim to reach the row count \param r
214 void setRows(size_t r);
216 /// appends texrow. the final line of this is merged with the first line of
218 void append(TexRow texrow);
220 /// for debugging purpose
221 void prepend(docstring_list &) const;
224 /// true iff same paragraph or math inset or begin_document
225 static bool sameParOrInsetMath(RowEntry entry1, RowEntry entry2);
226 /// computes the distance in pos or cell index
227 /// assumes it is the sameParOrInsetMath
228 static int comparePos(RowEntry entry1, RowEntry entry2);
233 /// TexString : dumb struct to pass around docstrings with TexRow information.
234 /// They are best created using otexstringstream.
235 /// They can be output to otexrowstreams and otexstreams.
236 /// A valid TexString has as many newlines in str as in texrow. Be careful not
237 /// to introduce a mismatch between the line and the row counts, as this will
238 /// assert in devel mode when outputting to a otexstream.
244 #if !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
245 /// Copy can be expensive and is not usually useful for TexString.
246 /// Force explicit copy, prefer move instead. This also prevents
247 /// move()s from being converted into copy silently.
248 explicit TexString(TexString const &) = default;
249 TexString(TexString && other) = default;
250 TexString & operator=(TexString const & other) = default;
251 TexString & operator=(TexString && other) = default;
253 //for gcc 4.6, nothing to do: it's enough to disable implicit copy during
254 // dev with more recent versions of gcc.
257 TexString() = default;
258 /// Texstring containing str and TexRow with enough lines which are empty
259 explicit TexString(docstring str);
260 /// Texstring containing str and texrow. Must be valid.
261 TexString(docstring str, TexRow texrow);
262 /// Ensure that the string and the TexRow have as many newlines.
267 // Standard container needs a complete type
268 class TexRow::RowEntryList {
269 // For each row we store a list of one special TextEntry and several
270 // RowEntries. (The order is important.) We only want one text entry
271 // because we do not want to store every position in the lyx file. On the
272 // other hand we want to record all math and table cells positions for
273 // enough precision. Usually the count of cells is easier to handle.
274 // The RowEntries are used for forward-search and the code preview pane.
275 std::vector<RowEntry> v_;
276 // The TextEntry is currently used for reverse-search and the error
277 // reporting dialog. Once the latter are adapted to rely on the more precise
278 // RowEntries above, it can be removed.
279 TextEntry text_entry_;
282 typedef std::vector<RowEntry>::iterator iterator;
283 iterator begin() { return v_.begin(); }
284 iterator end() { return v_.end(); }
286 typedef std::vector<RowEntry>::const_iterator const_iterator;
287 const_iterator begin() const { return v_.cbegin(); }
288 const_iterator end() const { return v_.cend(); }
290 RowEntryList() : text_entry_(TexRow::text_none) {}
292 // returns true if the row entry will appear in the row entry list
293 bool addEntry(RowEntry entry);
295 // the row entry will appear in the row entry list, but it never counts
296 // as a proper text entry.
297 void forceAddEntry(RowEntry entry);
299 // returns the TextEntry or TexRow::text_none if none
300 TextEntry getTextEntry() const;
303 void append(RowEntryList row);
307 bool operator==(TexRow::RowEntry entry1, TexRow::RowEntry entry2);