X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTexRow.cpp;h=8586a81c41d8fbaac884176d327a02cb8a951d77;hb=e2bc7ffae3eb387661064be8b9dc927742f9e7e8;hp=59a8779309d76a56e51bb53052a6a2658b348741;hpb=2b65ee6030e678dc4fe00793152e2d1feea6672f;p=lyx.git diff --git a/src/TexRow.cpp b/src/TexRow.cpp index 59a8779309..8586a81c41 100644 --- a/src/TexRow.cpp +++ b/src/TexRow.cpp @@ -4,82 +4,510 @@ * Licence details can be found in the file COPYING. * * \author Matthias Ettrich - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author John Levon + * \author Guillaume Munch * * Full author contact details are available in file CREDITS. */ #include +#include "Cursor.h" +#include "Paragraph.h" #include "TexRow.h" +#include "mathed/InsetMath.h" + #include "support/debug.h" +#include "support/docstring_list.h" #include +#include namespace lyx { -void TexRow::reset() + +bool TexRow::RowEntryList::addEntry(RowEntry const & entry) +{ + if (!entry.is_math) { + if (text_entry_ < size()) + return false; + else + text_entry_ = size(); + } + forceAddEntry(entry); + return true; +} + + +void TexRow::RowEntryList::forceAddEntry(RowEntry const & entry) +{ + if (size() == 0 || !(operator[](size() - 1) == entry)) + push_back(RowEntry(entry)); +} + + +TexRow::TextEntry TexRow::RowEntryList::getTextEntry() const { - rowlist.clear(); - lastid = -1; - lastpos = -1; + if (text_entry_ < size()) + return operator[](text_entry_).text; + return TexRow::text_none; } -void TexRow::start(int id, int pos) +TexRow::RowEntry TexRow::RowEntryList::entry() const { - lastid = id; - lastpos = pos; + if (0 < size()) + return operator[](0); + return TexRow::row_none; +} + + +void TexRow::RowEntryList::append(RowEntryList const & row) +{ + if (text_entry_ >= size()) + text_entry_ = row.text_entry_ + size(); + insert(end(), row.begin(), row.end()); +} + + +TexRow::TextEntry const TexRow::text_none = { -1, 0 }; +TexRow::RowEntry const TexRow::row_none = { false, { TexRow::text_none } }; + + +bool TexRow::isNone(TextEntry const & t) +{ + return t.id < 0; +} + + +bool TexRow::isNone(RowEntry const & r) +{ + return !r.is_math && isNone(r.text); +} + + +void TexRow::reset(bool enable) +{ + rowlist_.clear(); + current_row_ = RowEntryList(); + enabled_ = enable; +} + + +TexRow::RowEntry TexRow::textEntry(int id, int pos) +{ + RowEntry entry; + entry.is_math = false; + entry.text.pos = pos; + entry.text.id = id; + return entry; +} + + +TexRow::RowEntry TexRow::mathEntry(uid_type id, idx_type cell) +{ + RowEntry entry; + entry.is_math = true; + entry.math.cell = cell; + entry.math.id = id; + return entry; +} + + +bool operator==(TexRow::RowEntry const & entry1, + TexRow::RowEntry const & entry2) +{ + return entry1.is_math == entry2.is_math + && (entry1.is_math + ? (entry1.math.id == entry2.math.id + && entry1.math.cell == entry2.math.cell) + : (entry1.text.id == entry2.text.id + && entry1.text.pos == entry2.text.pos)); +} + + +bool TexRow::start(RowEntry entry) +{ + if (!enabled_) + return false; + return current_row_.addEntry(entry); +} + + +bool TexRow::start(int id, int pos) +{ + return start(textEntry(id,pos)); +} + + +void TexRow::forceStart(int id, int pos) +{ + if (!enabled_) + return; + return current_row_.forceAddEntry(textEntry(id,pos)); +} + + +void TexRow::startMath(uid_type id, idx_type cell) +{ + start(mathEntry(id,cell)); } void TexRow::newline() { - int const id = lastid; - RowList::value_type tmp(id, lastpos); - rowlist.push_back(tmp); + if (!enabled_) + return; + rowlist_.push_back(current_row_); + current_row_ = RowEntryList(); } +void TexRow::newlines(int num_lines) +{ + if (!enabled_) + return; + for (int i = 0; i < num_lines; ++i) { + newline(); + } +} + +void TexRow::finalize() +{ + if (!enabled_) + return; + newline(); +} + + +void TexRow::append(TexRow const & texrow) +{ + if (!enabled_ || !texrow.enabled_) + return; + RowList::const_iterator it = texrow.rowlist_.begin(); + RowList::const_iterator const end = texrow.rowlist_.end(); + if (it == end) { + current_row_.append(texrow.current_row_); + } else { + current_row_.append(*it++); + rowlist_.push_back(current_row_); + rowlist_.insert(rowlist_.end(), it, end); + current_row_ = texrow.current_row_; + } +} + + bool TexRow::getIdFromRow(int row, int & id, int & pos) const { - if (row <= 0 || row > int(rowlist.size())) { - id = -1; - pos = 0; - return false; + TextEntry t = text_none; + if (row <= int(rowlist_.size())) + while (row > 0 && isNone(t = rowlist_[row - 1].getTextEntry())) + --row; + id = t.id; + pos = t.pos; + return !isNone(t); +} + + +TexRow::RowEntry TexRow::rowEntryFromCursorSlice(CursorSlice const & slice) +{ + RowEntry entry; + InsetMath * insetMath = slice.asInsetMath(); + if (insetMath) { + entry.is_math = 1; + entry.math.id = insetMath->id(); + entry.math.cell = slice.idx(); + } else if (slice.text()) { + entry.is_math = 0; + entry.text.id = slice.paragraph().id(); + entry.text.pos = slice.pos(); + } else { + // should not happen + entry = row_none; } + return entry; +} - id = rowlist[row - 1].id(); - pos = rowlist[row - 1].pos(); - return true; + +bool TexRow::sameParOrInsetMath(RowEntry const & entry1, + RowEntry const & entry2) +{ + return entry1.is_math == entry2.is_math + && (entry1.is_math + ? (entry1.math.id == entry2.math.id) + : (entry1.text.id == entry2.text.id)); +} + + +// assumes it is sameParOrInsetMath +int TexRow::comparePos(RowEntry const & entry1, + RowEntry const & entry2) +{ + if (entry1.is_math) + return entry2.math.cell - entry1.math.cell; + else + return entry2.text.pos - entry1.text.pos; +} + + +// An iterator on RowList that goes top-down, left-right +// +// We assume that the end of RowList does not change, which makes things simpler +// +// Records a pair of iterators on the RowEntryList (row_it_, row_end_) and a +// pair of iterators on the current row (it_, it_end_). +// +// it_ always points to a valid position unless row_it_ == row_end_. +// +// We could turn this into a proper bidirectional iterator, but we don't need as +// much. +// +class TexRow::RowListIterator +{ +public: + RowListIterator(RowList::const_iterator r, + RowList::const_iterator r_end) + : row_it_(r), row_end_(r_end), + it_(r == r_end ? RowEntryList::const_iterator() : r->begin()), + it_end_(r == r_end ? RowEntryList::const_iterator() : r->end()) + { + normalize(); + } + + + RowListIterator() : + row_it_(RowList::const_iterator()), + row_end_(RowList::const_iterator()), + it_(RowEntryList::const_iterator()), + it_end_(RowEntryList::const_iterator()) { } + + + RowEntry const & operator*() + { + return *it_; + } + + + RowListIterator & operator++() + { + ++it_; + normalize(); + return *this; + } + + + bool atEnd() const + { + return row_it_ == row_end_; + } + + + bool operator==(RowListIterator const & a) const + { + return row_it_ == a.row_it_ && ((atEnd() && a.atEnd()) || it_ == a.it_); + } + + + bool operator!=(RowListIterator const & a) const { return !operator==(a); } + + + // Current row. + RowList::const_iterator const & row() const + { + return row_it_; + } +private: + // ensures that it_ points to a valid value unless row_it_ == row_end_ + void normalize() + { + if (row_it_ == row_end_) + return; + while (it_ == it_end_) { + ++row_it_; + if (row_it_ != row_end_) { + it_ = row_it_->begin(); + it_end_ = row_it_->end(); + } else + return; + } + } + // + RowList::const_iterator row_it_; + // + RowList::const_iterator row_end_; + // + RowEntryList::const_iterator it_; + // + RowEntryList::const_iterator it_end_; +}; + + +TexRow::RowListIterator TexRow::begin() const +{ + return RowListIterator(rowlist_.begin(), rowlist_.end()); } -int TexRow::getRowFromIdPos(int id, int pos) const +TexRow::RowListIterator TexRow::end() const { - bool foundid = false; + return RowListIterator(rowlist_.end(), rowlist_.end()); +} - // this loop finds the last *nonempty* row with the same id - // and position <= pos - RowList::const_iterator bestrow = rowlist.begin(); - RowList::const_iterator it = rowlist.begin(); - RowList::const_iterator const end = rowlist.end(); + +std::pair TexRow::rowFromDocIterator(DocIterator const & dit) const +{ + bool beg_found = false; + bool end_is_next = true; + int end_offset = 1; + size_t best_slice = 0; + RowEntry best_entry = row_none; + size_t const n = dit.depth(); + // this loop finds a pair (best_beg_row,best_end_row) where best_beg_row is + // the first row of the topmost possible CursorSlice, and best_end_row is + // the one just before the first row matching the next CursorSlice. + RowListIterator const begin = this->begin();//necessary disambiguation + RowListIterator const end = this->end(); + RowListIterator best_beg_entry; + //best last entry with same pos as the beg_entry, or first entry with pos + //immediately following the beg_entry + RowListIterator best_end_entry; + RowListIterator it = begin; for (; it != end; ++it) { - if (it->id() == id && it->pos() <= pos) { - foundid = true; - if (bestrow->id() != id || it->pos() > bestrow->pos()) - bestrow = it; - } else if (foundid) - break; + // Compute the best end row. + if (beg_found + && (!sameParOrInsetMath(*it, *best_end_entry) + || comparePos(*it, *best_end_entry) <= 0) + && sameParOrInsetMath(*it, best_entry)) { + switch (comparePos(*it, best_entry)) { + case 0: + // Either it is the last one that matches pos... + best_end_entry = it; + end_is_next = false; + end_offset = 1; + break; + case -1: { + // ...or it is the row preceding the first that matches pos+1 + if (!end_is_next) { + end_is_next = true; + if (it.row() != best_end_entry.row()) + end_offset = 0; + best_end_entry = it; + } + break; + } + } + } + // Compute the best begin row. It is better than the previous one if it + // matches either at a deeper level, or at the same level but not + // before. + for (size_t i = best_slice; i < n; ++i) { + TexRow::RowEntry entry_i = rowEntryFromCursorSlice(dit[i]); + if (sameParOrInsetMath(*it, entry_i)) { + if (comparePos(*it, entry_i) >= 0 + && (i > best_slice + || !beg_found + || !sameParOrInsetMath(*it, *best_beg_entry) + || (comparePos(*it, *best_beg_entry) <= 0 + && comparePos(entry_i, *best_beg_entry) != 0) + ) + ) { + beg_found = true; + end_is_next = false; + end_offset = 1; + best_slice = i; + best_entry = entry_i; + best_beg_entry = best_end_entry = it; + } + //found CursorSlice + break; + } + } + } + if (!beg_found) + return std::make_pair(-1,-1); + int const best_beg_row = distance(rowlist_.begin(), + best_beg_entry.row()) + 1; + int const best_end_row = distance(rowlist_.begin(), + best_end_entry.row()) + end_offset; + return std::make_pair(best_beg_row, best_end_row); +} + + +std::pair TexRow::rowFromCursor(Cursor const & cur) const +{ + DocIterator beg = cur.selectionBegin(); + std::pair beg_rows = rowFromDocIterator(beg); + if (cur.selection()) { + DocIterator end = cur.selectionEnd(); + if (!cur.selIsMultiCell() + // backwardPos asserts without the following test, IMO it's not my + // duty to check this. + && (end.top().pit() != 0 + || end.top().idx() != 0 + || end.top().pos() != 0)) + end.top().backwardPos(); + std::pair end_rows = rowFromDocIterator(end); + return std::make_pair(std::min(beg_rows.first, end_rows.first), + std::max(beg_rows.second, end_rows.second)); + } else + return std::make_pair(beg_rows.first, beg_rows.second); +} + + +// debugging functions + +/// +docstring TexRow::asString(RowEntry const & entry) +{ + odocstringstream os; + if (entry.is_math) + os << "(1," << entry.math.id << "," << entry.math.cell << ")"; + else + os << "(0," << entry.text.id << "," << entry.text.pos << ")"; + return os.str(); +} + + +///prepends the texrow to the source given by tex, for debugging purpose +void TexRow::prepend(docstring_list & tex) const +{ + size_type const prefix_length = 25; + if (tex.size() < rowlist_.size()) + tex.resize(rowlist_.size()); + std::vector::const_iterator it = rowlist_.begin(); + std::vector::const_iterator const beg = rowlist_.begin(); + std::vector::const_iterator const end = rowlist_.end(); + for (; it < end; ++it) { + docstring entry; + std::vector::const_iterator it2 = it->begin(); + std::vector::const_iterator const end2 = it->end(); + for (; it2 != end2; ++it2) + entry += asString(*it2); + if (entry.length() < prefix_length) + entry = entry + docstring(prefix_length - entry.length(), L' '); + ptrdiff_t i = it - beg; + tex[i] = entry + " " + tex[i]; + } +} + + + +LyXErr & operator<<(LyXErr & l, TexRow & texrow) +{ + if (l.enabled()) { + for (int i = 0; i < texrow.rows(); i++) { + int id,pos; + if (texrow.getIdFromRow(i+1,id,pos) && id>0) + l << i+1 << ":" << id << ":" << pos << "\n"; + } } - if (!foundid) - return rowlist.size(); - return distance(rowlist.begin(), bestrow); + return l; } + } // namespace lyx