X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTexRow.cpp;h=460a141600194adccca48685bab7af85cac7ef2d;hb=79cf3f5ec1088e7de988e889247ec300d42fb70b;hp=e7165e95fad32650f4c0f4644f25e8510623c4ae;hpb=f630be890494c849981e4fb52ea4740506e92bed;p=lyx.git

diff --git a/src/TexRow.cpp b/src/TexRow.cpp
index e7165e95fa..460a141600 100644
--- a/src/TexRow.cpp
+++ b/src/TexRow.cpp
@@ -4,87 +4,676 @@
  * 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 <config.h>
 
+#include "Buffer.h"
+#include "Cursor.h"
+#include "FuncRequest.h"
+#include "Paragraph.h"
 #include "TexRow.h"
-#include "debug.h"
+
+#include "mathed/InsetMath.h"
+
+#include "support/convert.h"
+#include "support/debug.h"
+#include "support/docstring_list.h"
+#include "support/lassert.h"
 
 #include <algorithm>
+#include <iterator>
+#include <sstream>
+
+using namespace std;
 
 
 namespace lyx {
 
-using std::find_if;
 
+TexString::TexString(docstring s)
+	: str(move(s)), texrow(TexRow())
+{
+	texrow.setRows(1 + count(str.begin(), str.end(), '\n'));
+}
 
-namespace {
 
-/// function object returning true when row number is found
-class same_rownumber {
-public:
-	same_rownumber(int row) : row_(row) {}
-	bool operator()(TexRow::RowList::value_type const & vt) const {
-		return vt.rownumber() == row_;
+TexString::TexString(docstring s, TexRow t)
+	: str(move(s)), texrow(move(t))
+{
+	validate();
+}
+
+
+void TexString::validate()
+{
+	size_t lines = 1 + count(str.begin(), str.end(), '\n');
+	size_t rows = texrow.rows();
+	bool valid = lines == rows;
+	if (!valid)
+		LYXERR0("TexString has " << lines << " lines but " << rows << " rows." );
+	// Assert in devel mode.  This is important to catch bugs early, otherwise
+	// they might be hard to notice and find.  Recover gracefully in release
+	// mode.
+	LASSERT(valid, texrow.setRows(lines));
+}
+
+
+bool TexRow::RowEntryList::addEntry(RowEntry entry)
+{
+	switch (entry.type) {
+	case text_entry:
+		if (isNone(text_entry_))
+			text_entry_ = entry.text;
+		else if (!v_.empty() && TexRow::sameParOrInsetMath(v_.back(), entry))
+			return false;
+		break;
+	default:
+		break;
 	}
+	forceAddEntry(entry);
+	return true;
+}
 
-private:
-	int row_;
-};
 
-} // namespace anon
+void TexRow::RowEntryList::forceAddEntry(RowEntry entry)
+{
+	if (v_.empty() || !(v_.back() == entry))
+		v_.push_back(entry);
+}
+
+
+TexRow::TextEntry TexRow::RowEntryList::getTextEntry() const
+{
+	if (!isNone(text_entry_))
+		return text_entry_;
+	return TexRow::text_none;
+}
+
+
+void TexRow::RowEntryList::append(RowEntryList row)
+{
+	if (isNone(text_entry_))
+		text_entry_ = row.text_entry_;
+	move(row.begin(), row.end(), back_inserter(v_));
+}
+
+
+TexRow::TexRow()
+{
+	reset();
+}
+
+
+TexRow::TextEntry const TexRow::text_none = { -1, 0 };
+TexRow::RowEntry const TexRow::row_none = TexRow::textEntry(-1, 0);
+
+
+//static
+bool TexRow::isNone(TextEntry t)
+{
+	return t.id < 0;
+}
+
+
+//static
+bool TexRow::isNone(RowEntry r)
+{
+	return r.type == text_entry && isNone(r.text);
+}
 
 
 void TexRow::reset()
 {
-	rowlist.clear();
-	count = 0;
-	lastid = -1;
-	lastpos = -1;
+	rowlist_.clear();
+	newline();
 }
 
 
-void TexRow::start(int id, int pos)
+TexRow::RowEntryList & TexRow::currentRow()
 {
-	lastid = id;
-	lastpos = pos;
+	return rowlist_.back();
+}
+
+
+//static
+TexRow::RowEntry TexRow::textEntry(int id, pos_type pos)
+{
+	RowEntry entry;
+	entry.type = text_entry;
+	entry.text.pos = pos;
+	entry.text.id = id;
+	return entry;
+}
+
+
+//static
+TexRow::RowEntry TexRow::mathEntry(uid_type id, idx_type cell)
+{
+	RowEntry entry;
+	entry.type = math_entry;
+	entry.math.cell = cell;
+	entry.math.id = id;
+	return entry;
+}
+
+
+//static
+TexRow::RowEntry TexRow::beginDocument()
+{
+	RowEntry entry;
+	entry.type = begin_document;
+	entry.begindocument = {};
+	return entry;
+}
+
+
+bool operator==(TexRow::RowEntry entry1, TexRow::RowEntry entry2)
+{
+	if (entry1.type != entry2.type)
+		return false;
+	switch (entry1.type) {
+	case TexRow::text_entry:
+		return entry1.text.id == entry2.text.id
+			&& entry1.text.pos == entry2.text.pos;
+	case TexRow::math_entry:
+		return entry1.math.id == entry2.math.id
+			&& entry1.math.cell == entry2.math.cell;
+	case TexRow::begin_document:
+		return true;
+	default:
+		return false;
+	}
+}
+
+
+bool TexRow::start(RowEntry entry)
+{
+	return currentRow().addEntry(entry);
+}
+
+
+bool TexRow::start(int id, pos_type pos)
+{
+	return start(textEntry(id,pos));
+}
+
+
+void TexRow::forceStart(int id, pos_type pos)
+{
+	return currentRow().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, ++count);
-	rowlist.push_back(tmp);
+	rowlist_.push_back(RowEntryList());
+}
+
+
+void TexRow::newlines(size_t num_lines)
+{
+	while (num_lines--)
+		newline();
+}
+
+
+void TexRow::append(TexRow other)
+{
+	RowList::iterator it = other.rowlist_.begin();
+	RowList::iterator const end = other.rowlist_.end();
+	LASSERT(it != end, return);
+	currentRow().append(move(*it++));
+	move(it, end, back_inserter(rowlist_));
 }
 
 
-bool TexRow::getIdFromRow(int row, int & id, int & pos) const
+pair<TexRow::TextEntry, TexRow::TextEntry>
+TexRow::getEntriesFromRow(int const row) const
 {
-	RowList::const_iterator cit =
-		find_if(rowlist.begin(), rowlist.end(),
-			same_rownumber(row));
+	// FIXME: Take math entries into account, take table cells into account and
+	//        get rid of the ad hoc special text entry for each row.
+	//
+	// FIXME: A yellow note alone on its paragraph makes the reverse-search on
+	//        the subsequent line inaccurate. Get rid of text entries that
+	//        correspond to no output by delaying their addition, at the level
+	//        of otexrowstream, until a character is actually output.
+	//
+	LYXERR(Debug::LATEX, "getEntriesFromRow: row " << row << " requested");
 
-	if (cit != rowlist.end()) {
-		id = cit->id();
-		pos = cit->pos();
+	// check bounds for row - 1, our target index
+	if (row <= 0)
+		return {text_none, text_none};
+	size_t const i = static_cast<size_t>(row - 1);
+	if (i >= rowlist_.size())
+		return {text_none, text_none};
+
+	// find the start entry
+	TextEntry const start = [&]() {
+		for (size_t j = i; j > 0; --j) {
+			if (!isNone(rowlist_[j].getTextEntry()))
+				return rowlist_[j].getTextEntry();
+			// Check the absence of begin_document at row j. The begin_document row
+			// entry is used to prevent mixing of body and preamble.
+			for (RowEntry entry : rowlist_[j])
+				if (entry.type == begin_document)
+					return text_none;
+		}
+		return text_none;
+	} ();
+
+	// find the end entry
+	TextEntry end = [&]() {
+		if (isNone(start))
+			return text_none;
+		// select up to the last position of the starting paragraph as a
+		// fallback
+		TextEntry last_pos = {start.id, -1};
+		// find the next occurence of paragraph start.id
+		for (size_t j = i + 1; j < rowlist_.size(); ++j) {
+			for (RowEntry entry : rowlist_[j]) {
+				if (entry.type == begin_document)
+					// what happens in the preamble remains in the preamble
+					return last_pos;
+				if (entry.type == text_entry && entry.text.id == start.id)
+					return entry.text;
+			}
+		}
+		return last_pos;
+	} ();
+
+	// The following occurs for a displayed math inset for instance (for good
+	// reasons involving subtleties of the algorithm in getRowFromDocIterator).
+	// We want this inset selected.
+	if (start.id == end.id && start.pos == end.pos)
+		++end.pos;
+
+	return {start, end};
+}
+
+
+pair<DocIterator, DocIterator> TexRow::getDocIteratorsFromRow(
+    int const row,
+    Buffer const & buf) const
+{
+	TextEntry start, end;
+	tie(start,end) = getEntriesFromRow(row);
+	return getDocIteratorsFromEntries(start, end, buf);
+}
+
+
+//static
+pair<DocIterator, DocIterator> TexRow::getDocIteratorsFromEntries(
+	    TextEntry start,
+	    TextEntry end,
+	    Buffer const & buf)
+{
+	auto set_pos = [](DocIterator & dit, pos_type pos) {
+		dit.pos() = (pos >= 0) ? min(pos, dit.lastpos())
+		                       // negative pos values are counted from the end
+		                       : max(dit.lastpos() + pos + 1, pos_type(0));
+	};
+	// Finding start
+	DocIterator dit_start = buf.getParFromID(start.id);
+	if (dit_start)
+		set_pos(dit_start, start.pos);
+	// Finding end
+	DocIterator dit_end = buf.getParFromID(end.id);
+	if (dit_end) {
+		set_pos(dit_end, end.pos);
+		// Step backwards to prevent selecting the beginning of another
+		// paragraph.
+		if (dit_end.pos() == 0 && !dit_end.top().at_cell_begin()) {
+			CursorSlice end_top = dit_end.top();
+			end_top.backwardPos();
+			if (dit_start && end_top != dit_start.top())
+				dit_end.top() = end_top;
+		}
+		dit_end.boundary(true);
+	}
+	return {dit_start, dit_end};
+}
+
+
+//static
+FuncRequest TexRow::goToFunc(TextEntry start, TextEntry end)
+{
+	return {LFUN_PARAGRAPH_GOTO,
+			convert<string>(start.id) + " " + convert<string>(start.pos) + " " +
+			convert<string>(end.id) + " " + convert<string>(end.pos)};
+}
+
+
+FuncRequest TexRow::goToFuncFromRow(int const row) const
+{
+	TextEntry start, end;
+	tie(start,end) = getEntriesFromRow(row);
+	LYXERR(Debug::LATEX,
+	       "goToFuncFromRow: for row " << row << ", TexRow has found "
+	       "start (id=" << start.id << ",pos=" << start.pos << "), "
+	       "end (id=" << end.id << ",pos=" << end.pos << ")");
+	return goToFunc(start, end);
+}
+
+
+//static
+TexRow::RowEntry TexRow::rowEntryFromCursorSlice(CursorSlice const & slice)
+{
+	RowEntry entry;
+	InsetMath * insetMath = slice.asInsetMath();
+	if (insetMath) {
+		entry.type = math_entry;
+		entry.math.id = insetMath->id();
+		entry.math.cell = slice.idx();
+	} else if (slice.text()) {
+		entry.type = text_entry;
+		entry.text.id = slice.paragraph().id();
+		entry.text.pos = slice.pos();
+	} else
+		LASSERT(false, return row_none);
+	return entry;
+}
+
+
+//static
+bool TexRow::sameParOrInsetMath(RowEntry entry1, RowEntry entry2)
+{
+	if (entry1.type != entry2.type)
+		return false;
+	switch (entry1.type) {
+	case TexRow::text_entry:
+		return entry1.text.id == entry2.text.id;
+	case TexRow::math_entry:
+		return entry1.math.id == entry2.math.id;
+	case TexRow::begin_document:
 		return true;
+	default:
+		return false;
+	}
+}
+
+
+//static
+int TexRow::comparePos(RowEntry entry1, RowEntry entry2)
+{
+	// assume it is sameParOrInsetMath
+	switch (entry1.type /* equal to entry2.type */) {
+	case TexRow::text_entry:
+		return entry2.text.pos - entry1.text.pos;
+	case TexRow::math_entry:
+		return entry2.math.cell - entry1.math.cell;
+	case TexRow::begin_document:
+		return 0;
+	default:
+		return 0;
+	}
+}
+
+
+// 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());
+}
+
+
+TexRow::RowListIterator TexRow::end() const
+{
+	return RowListIterator(rowlist_.end(), rowlist_.end());
+}
+
+
+pair<int,int> TexRow::rowFromDocIterator(DocIterator const & dit) const
+{
+	// Do not change anything in this algorithm if unsure.
+	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) {
+		// 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) {
+			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 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 make_pair(best_beg_row, best_end_row);
+}
+
+
+pair<int,int> TexRow::rowFromCursor(Cursor const & cur) const
+{
+	DocIterator beg = cur.selectionBegin();
+	pair<int,int> beg_rows = rowFromDocIterator(beg);
+	if (cur.selection()) {
+		DocIterator end = cur.selectionEnd();
+		if (!cur.selIsMultiCell() && !end.top().at_cell_begin())
+			end.top().backwardPos();
+		pair<int,int> end_rows = rowFromDocIterator(end);
+		return make_pair(min(beg_rows.first, end_rows.first),
+		                 max(beg_rows.second, end_rows.second));
+	} else
+		return make_pair(beg_rows.first, beg_rows.second);
+}
+
+
+size_t TexRow::rows() const
+{
+	return rowlist_.size();
+}
+
+
+void TexRow::setRows(size_t r)
+{
+	rowlist_.resize(r, RowEntryList());
+}
+
+
+// debugging functions
+
+///
+docstring TexRow::asString(RowEntry entry)
+{
+	odocstringstream os;
+	switch (entry.type) {
+	case TexRow::text_entry:
+		os << "(par " << entry.text.id << "," << entry.text.pos << ")";
+		break;
+	case TexRow::math_entry:
+		os << "(" << entry.math.id << "," << entry.math.cell << ")";
+		break;
+	case TexRow::begin_document:
+		os << "(begin_document)";
+		break;
+	default:
+		break;
 	}
-	id = -1;
-	pos = 0;
-	return false;
+	return os.str();
 }
 
 
-TexRow & TexRow::operator+=(TexRow const & tr)
+///prepends the texrow to the source given by tex, for debugging purpose
+void TexRow::prepend(docstring_list & tex) const
 {
-	rowlist.insert(rowlist.end(), tr.rowlist.begin(), tr.rowlist.end());
-	return *this;
+	size_type const prefix_length = 25;
+	if (tex.size() < rowlist_.size())
+		tex.resize(rowlist_.size());
+	auto it = rowlist_.cbegin();
+	auto const beg = rowlist_.cbegin();
+	auto const end = rowlist_.cend();
+	for (; it < end; ++it) {
+		docstring entry;
+		for (RowEntry const & e : *it)
+			entry += asString(e);
+		if (entry.length() < prefix_length)
+			entry = entry + docstring(prefix_length - entry.length(), ' ');
+		ptrdiff_t i = it - beg;
+		tex[i] = entry + "  " + tex[i];
+	}
 }