src/TexRow.h

   1 // -*- C++ -*-
   2 /**
   3  * \file TexRow.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Matthias Ettrich
   8  * \author Lars Gullik Bjønnes
   9  * \author John Levon
  10  * \author Guillaume Munch
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 /* Note about debugging options:
  16  *
  17  * When compiled in devel mode and run with the option -dbg latex, two ways
  18  * of debugging TexRow are available:
  19  *
  20  * 1. The source view panel prepends the full TexRow information to the LaTeX
  21  *    output.
  22  *
  23  * 2. Clicking on any line in the source view moves the buffer to the location
  24  *    recognised by TexRow.
  25  *
  26  */
  27
  28 #ifndef TEXROW_H
  29 #define TEXROW_H
  30
  31 #include "support/debug.h"
  32 #include "support/types.h"
  33
  34 #include <vector>
  35
  36 namespace lyx {
  37
  38 class LyXErr;
  39 class Buffer;
  40 class Cursor;
  41 class CursorSlice;
  42 class DocIterator;
  43 class docstring_list;
  44
  45 /// types for cells and math insets
  46 typedef void const * uid_type;
  47 typedef size_t idx_type;
  48
  49
  50 /// an individual par id/pos <=> row mapping
  51 struct TextEntry { int id; pos_type pos; };
  52
  53 /// an individual math id/cell <=> row mapping
  54 struct MathEntry { uid_type id; idx_type cell; };
  55
  56 /// a container for passing entries around
  57 struct RowEntry {
  58         bool is_math;// true iff the union is a math
  59         union {
  60                 struct TextEntry text;
  61                 struct MathEntry math;
  62         };
  63 };
  64
  65
  66 /// Represents the correspondence between paragraphs and the generated
  67 /// LaTeX file
  68
  69 class TexRow {
  70         /// id/pos correspondence for a single row
  71         class RowEntryList;
  72
  73         /// container of id/pos <=> row mapping
  74         /// invariant: in any enabled_ TexRow, rowlist_ will contain at least one
  75         /// Row (the current row)
  76         typedef std::vector<RowEntryList> RowList;
  77         ///
  78         RowList rowlist_;
  79         ///
  80         RowEntryList & currentRow();
  81
  82         ///
  83         class RowListIterator;
  84         ///
  85         RowListIterator begin() const;
  86         ///
  87         RowListIterator end() const;
  88 public:
  89         ///
  90         TexRow();
  91
  92 #if !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
  93         /// Copy can be expensive and is not usually useful for TexRow.
  94         /// Force explicit copy, prefer move instead. This also prevents
  95         /// move()s from being converted into copy silently.
  96         explicit TexRow(TexRow const & other) = default;
  97         TexRow(TexRow && other) = default;
  98         TexRow & operator=(TexRow const & other) = default;
  99         TexRow & operator=(TexRow && other) = default;
 100 # else
 101         //for gcc 4.6, nothing to do: it's enough to disable implicit copy during
 102         // dev with more recent versions of gcc.
 103 #endif
 104
 105         /// Clears structure.
 106         void reset();
 107
 108         static const TextEntry text_none;
 109         static const RowEntry row_none;
 110         /// Returns true if RowEntry is devoid of information
 111         static bool isNone(RowEntry entry);
 112         /// Returns true if TextEntry is devoid of information
 113         static bool isNone(TextEntry entry);
 114
 115         /// Converts a CursorSlice into a RowEntry
 116         static RowEntry rowEntryFromCursorSlice(CursorSlice const & slice);
 117         /// Encapsulates the paragraph and position for later use
 118         static RowEntry textEntry(int id, pos_type pos);
 119         /// Encapsulates a cell and position for later use
 120         static RowEntry mathEntry(uid_type id, idx_type cell);
 121
 122         /// for debugging purposes
 123         static docstring asString(RowEntry entry);
 124
 125         /// Defines the row information for the current line
 126         /// returns true if this entry will appear on the current row
 127         bool start(RowEntry entry);
 128         /// Defines the paragraph and position for the current line
 129         /// returns true if this entry will appear on the current row
 130         bool start(int id, pos_type pos);
 131         /// Defines a cell and position for the current line.  Always appear in the
 132         /// current row.
 133         void startMath(uid_type id, idx_type cell);
 134         /// Defines the paragraph for the current cell-like inset.  Always appears
 135         /// in the current row like a math cell, but is detached from the normal
 136         /// text flow. Note: since the cell idx is not recorded it does not work as
 137         /// well as for math grids; if we were to do that properly we would need to
 138         /// access the id of the parent Tabular inset from the CursorSlice.
 139         void forceStart(int id, pos_type pos);
 140
 141         /// Insert node when line is completed
 142         void newline();
 143         /// Insert multiple nodes when zero or more lines are completed
 144         void newlines(size_t num_lines);
 145
 146         /**
 147          * getEntriesFromRow - find pids and position for a given row
 148          * @param row row number to find
 149          * @return a pair of TextEntry denoting the start and end of the position.
 150          * The TextEntry values can be isNone(). If no row is found then the first
 151          * value isNone().
 152          */
 153         std::pair<TextEntry,TextEntry> getEntriesFromRow(int row) const;
 154
 155         /**
 156          * getDocIteratorFromRow - find pids and positions for a given row
 157          * @param row number to find
 158          * @param buffer here to look
 159          * @return a pair of DocIterators the start and end of the position.
 160          * The DocIterators can be invalid. The starting DocIterator being invalid
 161          * means that no row was found. Note: there is no guarantee that the
 162          * DocIterators are in the same inset or even at the same depth.
 163          */
 164         std::pair<DocIterator, DocIterator> getDocIteratorFromRow(
 165             int row,
 166             Buffer const & buf) const;
 167         //TODO: remove the following by replacing it with the above
 168         bool getIdFromRow(int row, int & id, int & pos) const;
 169
 170         /// Finds the best pair of rows for dit
 171         /// returns (-1,-1) if not found.
 172         std::pair<int,int> rowFromDocIterator(DocIterator const & dit) const;
 173
 174         /// Finds the best pair of rows for cursor, taking the selection into
 175         /// account
 176         /// returns (-1,-1) if not found.
 177         std::pair<int,int> rowFromCursor(Cursor const & dit) const;
 178
 179         /// Returns the number of rows contained
 180         size_t rows() const;
 181         /// Fill or trim to reach the row count \param r
 182         void setRows(size_t r);
 183
 184         /// appends texrow. the final line of this is merged with the first line of
 185         /// texrow.
 186         void append(TexRow texrow);
 187
 188         /// for debugging purpose
 189         void prepend(docstring_list &) const;
 190
 191 private:
 192         /// true iff same paragraph or math inset
 193         static bool sameParOrInsetMath(RowEntry entry1, RowEntry entry2);
 194         /// computes the distance in pos or cell index
 195         /// assumes it is the sameParOrInsetMath
 196         static int comparePos(RowEntry entry1, RowEntry entry2);
 197
 198 };
 199
 200
 201 /// TexString : dumb struct to pass around docstrings with TexRow information.
 202 /// They are best created using oTexStringstream.
 203 /// They can be output to otexrowstreams and otexstreams.
 204 /// A valid TexString has as many newlines in str as in texrow. Be careful not
 205 /// to introduce a mismatch between the line and the row counts, as this will
 206 /// assert in devel mode when outputting to a otexstream.
 207 struct TexString {
 208         ///
 209         docstring str;
 210         ///
 211         TexRow texrow;
 212 #if !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
 213         /// Copy can be expensive and is not usually useful for TexString.
 214         /// Force explicit copy, prefer move instead. This also prevents
 215         /// move()s from being converted into copy silently.
 216         explicit TexString(TexString const &) = default;
 217         TexString(TexString && other) = default;
 218         TexString & operator=(TexString const & other) = default;
 219         TexString & operator=(TexString && other) = default;
 220 # else
 221         //for gcc 4.6, nothing to do: it's enough to disable implicit copy during
 222         // dev with more recent versions of gcc.
 223 #endif
 224         ///
 225         TexString() = default;
 226         /// ensure that the string and the TexRow have as many newlines.
 227         void validate();
 228 };
 229
 230
 231 // Standard container needs a complete type
 232 class TexRow::RowEntryList {
 233         // For each row we store a list of one special TextEntry and several
 234         // RowEntries. (The order is important.)  We only want one text entry
 235         // because we do not want to store every position in the lyx file. On the
 236         // other hand we want to record all math and table cells positions for
 237         // enough precision. Usually the count of cells is easier to handle.
 238         // The RowEntries are used for forward-search and the code preview pane.
 239         std::vector<RowEntry> v_;
 240         // The TextEntry is currently used for reverse-search and the error
 241         // reporting dialog. Once the latter are adapted to rely on the more precise
 242         // RowEntries above, it can be removed.
 243         TextEntry text_entry_;
 244
 245 public:
 246         typedef std::vector<RowEntry>::iterator iterator;
 247         iterator begin() { return v_.begin(); }
 248         iterator end() { return v_.end(); }
 249         ///
 250         typedef std::vector<RowEntry>::const_iterator const_iterator;
 251         const_iterator begin() const { return v_.cbegin(); }
 252         const_iterator end() const { return v_.cend(); }
 253         ///
 254         RowEntryList() : text_entry_(TexRow::text_none) {}
 255
 256         // returns true if the row entry will appear in the row entry list
 257         bool addEntry(RowEntry entry);
 258
 259         // the row entry will appear in the row entry list, but it never counts
 260         // as a proper text entry.
 261         void forceAddEntry(RowEntry entry);
 262
 263         // returns the TextEntry or TexRow::text_none if none
 264         TextEntry getTextEntry() const;
 265
 266         // appends a row
 267         void append(RowEntryList row);
 268 };
 269
 270
 271 bool operator==(RowEntry entry1, RowEntry entry2);
 272
 273
 274 LyXErr & operator<<(LyXErr &, TexRow const &);
 275
 276
 277 } // namespace lyx
 278
 279 #endif // TEXROW_H