X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FUndo.cpp;h=7b924c7b49a6e73b0bbca83287daa9f60a538860;hb=44cdffa39e9160bde46d824f1915f9ef3084b53e;hp=95eb160d60c9c19494cf3646fac858b90964db48;hpb=11ca1406671f3e7b126bbe9b51694e8d32ba161c;p=lyx.git

diff --git a/src/Undo.cpp b/src/Undo.cpp
index 95eb160d60..7b924c7b49 100644
--- a/src/Undo.cpp
+++ b/src/Undo.cpp
@@ -195,7 +195,7 @@ private:
 struct Undo::Private
 {
 	Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true),
-				   group_id(0), group_level(0) {}
+				   group_id_(0), group_level_(0) {}
 
 	// Do one undo/redo step
 	void doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
@@ -232,9 +232,11 @@ struct Undo::Private
 	bool undo_finished_;
 
 	/// Current group Id.
-	size_t group_id;
+	size_t group_id_;
 	/// Current group nesting nevel.
-	size_t group_level;
+	size_t group_level_;
+	/// the position of cursor before the group was created
+	CursorData group_cur_before_;
 };
 
 
@@ -263,8 +265,8 @@ void Undo::clear()
 	d->undo_finished_ = true;
 	// We used to do that, but I believe it is better to keep
 	// groups (only used in Buffer::reload for now (JMarc)
-	//d->group_id = 0;
-	//d->group_level = 0;
+	//d->group_id_ = 0;
+	//d->group_level_ = 0;
 }
 
 
@@ -308,9 +310,9 @@ void Undo::Private::doRecordUndo(UndoKind kind,
 	CursorData const & cur_before,
 	UndoElementStack & stack)
 {
-	if (!group_level) {
+	if (!group_level_) {
 		LYXERR0("There is no group open (creating one)");
-		++group_id;
+		++group_id_;
 	}
 
 	if (first_pit > last_pit)
@@ -338,10 +340,11 @@ void Undo::Private::doRecordUndo(UndoKind kind,
 		return;
 	}
 
-	LYXERR(Debug::UNDO, "Create undo element of group " << group_id);
+	LYXERR(Debug::UNDO, "Create undo element of group " << group_id_);
 	// create the position information of the Undo entry
-	UndoElement undo(kind, cur_before, cell, from, end, 0, 0,
-	                 buffer_.isClean(), group_id);
+	UndoElement undo(kind,
+	      group_cur_before_.empty() ? cur_before : group_cur_before_,
+	      cell, from, end, 0, 0, buffer_.isClean(), group_id_);
 
 	// fill in the real data to be saved
 	if (cell.inMathed()) {
@@ -390,17 +393,18 @@ void Undo::Private::recordUndo(UndoKind kind,
 
 
 void Undo::Private::doRecordUndoBufferParams(CursorData const & cur_before,
-									   UndoElementStack & stack)
+                                             UndoElementStack & stack)
 {
-	if (!group_level) {
+	if (!group_level_) {
 		LYXERR0("There is no group open (creating one)");
-		++group_id;
+		++group_id_;
 	}
 
-	LYXERR(Debug::UNDO, "Create full buffer undo element of group " << group_id);
+	LYXERR(Debug::UNDO, "Create full buffer undo element of group " << group_id_);
 	// create the position information of the Undo entry
-	UndoElement undo(cur_before, buffer_.params(), buffer_.isClean(),
-					 group_id);
+	UndoElement undo(group_cur_before_.empty() ? cur_before : group_cur_before_,
+                     buffer_.params(), buffer_.isClean(),
+					 group_id_);
 
 	// push the undo entry to undo stack
 	stack.push(undo);
@@ -434,10 +438,12 @@ void Undo::Private::doTextUndoOrRedo(CursorData & cur, UndoElementStack & stack,
 
 	if (undo.bparams)
 		doRecordUndoBufferParams(undo.cur_after, otherstack);
-	else
+	else {
+		LATTEST(undo.end <= cell_dit.lastpit());
 		doRecordUndo(ATOMIC_UNDO, cell_dit,
 					 undo.from, cell_dit.lastpit() - undo.end, undo.cur_after,
 					 otherstack);
+	}
 	otherstack.top().cur_after = undo.cur_before;
 
 	// This does the actual undo/redo.
@@ -544,34 +550,43 @@ bool Undo::textRedo(CursorData & cur)
 
 void Undo::beginUndoGroup()
 {
-	if (d->group_level == 0) {
+	if (d->group_level_ == 0) {
 		// create a new group
-		++d->group_id;
-		LYXERR(Debug::UNDO, "+++++++Creating new group " << d->group_id);
+		++d->group_id_;
+		LYXERR(Debug::UNDO, "+++++++Creating new group " << d->group_id_);
 	}
-	++d->group_level;
+	++d->group_level_;
+}
+
+
+void Undo::beginUndoGroup(CursorData const & cur_before)
+{
+	beginUndoGroup();
+	if (d->group_cur_before_.empty())
+		d->group_cur_before_ = cur_before;
 }
 
 
 void Undo::endUndoGroup()
 {
-	if (d->group_level == 0) {
+	if (d->group_level_ == 0) {
 		LYXERR0("There is no undo group to end here");
 		return;
 	}
-	--d->group_level;
-	if (d->group_level == 0) {
+	--d->group_level_;
+	if (d->group_level_ == 0) {
 		// real end of the group
-		LYXERR(Debug::UNDO, "-------End of group " << d->group_id);
+		d->group_cur_before_ = CursorData();
+		LYXERR(Debug::UNDO, "-------End of group " << d->group_id_);
 	}
 }
 
 
-void Undo::endUndoGroup(CursorData const & cur)
+void Undo::endUndoGroup(CursorData const & cur_after)
 {
 	endUndoGroup();
 	if (!d->undostack_.empty() && d->undostack_.top().cur_after.empty())
-		d->undostack_.top().cur_after = cur;
+		d->undostack_.top().cur_after = cur_after;
 }
 
 
@@ -587,6 +602,19 @@ void Undo::recordUndo(CursorData const & cur, pit_type from, pit_type to)
 }
 
 
+void Undo::recordUndoInset(CursorData const & cur, Inset const * inset)
+{
+	if (!inset || inset == &cur.inset()) {
+		DocIterator c = cur;
+		c.pop_back();
+		d->recordUndo(ATOMIC_UNDO, c, c.pit(), c.pit(), cur);
+	} else if (inset == cur.nextInset())
+		recordUndo(cur);
+	else
+		LYXERR0("Inset not found, no undo stack added.");
+}
+
+
 void Undo::recordUndoBufferParams(CursorData const & cur)
 {
 	d->recordUndoBufferParams(cur);
@@ -604,5 +632,18 @@ void Undo::recordUndoFullBuffer(CursorData const & cur)
 	endUndoGroup();
 }
 
+/// UndoGroupHelper class stuff
+
+void UndoGroupHelper::resetBuffer(Buffer * buf)
+{
+	if (buf == buffer_)
+		return;
+	if (buffer_)
+		buffer_->undo().endUndoGroup();
+	buffer_ = buf;
+	if (buffer_)
+		buffer_->undo().beginUndoGroup();
+}
+
 
 } // namespace lyx