From 8c2010510680f238605998b875b6b3d824fcd35b Mon Sep 17 00:00:00 2001
From: Michael Schmitt <michael.schmitt@teststep.org>
Date: Sun, 29 Oct 2006 21:48:23 +0000
Subject: [PATCH] change tracking:

	* changes.[Ch]: introduce isSimilarTo(...);
	restore original operator==;
	When merging two adjacent changes, the changetime is not considered,
	only the equality of the change type and author is checked (in method
	isSimilarTo(...)). If two changes are in fact merged (in method merge()),
	the later change time is preserved.



git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@15608 a592a061-630c-0410-9148-cb99ea01b6c8
---
 src/changes.C | 32 ++++++++++++++++++--------------
 src/changes.h |  3 +++
 2 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/changes.C b/src/changes.C
index 53d89e494e..e3cbdf5270 100644
--- a/src/changes.C
+++ b/src/changes.C
@@ -16,7 +16,6 @@
 #include "changes.h"
 #include "debug.h"
 
-#include <cmath>
 #include <boost/assert.hpp>
 
 
@@ -31,27 +30,32 @@ using std::max;
  * Class Change has a changetime field that specifies the exact time at which
  * a specific change was made. The change time is used as a guidance for the
  * user while editing his document. Presently, it is not considered for LaTeX
- * export. To avoid that every keystroke results in a separate change, a 
- * tolerance interval of 5 minutes is used. That means if there are two adjacent
- * changes that only differ in their change time with abs(ct1 - ct2) < 300 sec,
- * they will be merged (and the later change time is preserved).
- * Technically, the check for equality (or similarity) is made in operator==(...).
- * The merging of similar changes happens in method merge().
+ * export.
+ * When merging two adjacent changes, the changetime is not considered,
+ * only the equality of the change type and author is checked (in method
+ * isSimilarTo(...)). If two changes are in fact merged (in method merge()),
+ * the later change time is preserved. 
  */
 
-bool operator==(Change const & l, Change const & r)
+bool Change::isSimilarTo(Change const & change)
 {
-	if (l.type != r.type) {
+	if (type != change.type) {
 		return false;
 	}
 
-	if (l.type == Change::UNCHANGED) {
+	if (type == Change::UNCHANGED) {
 		return true;
 	}
 
-	return l.author == r.author
-	       // both changes made within 5 minutes?
-	       && abs(difftime(l.changetime, r.changetime)) < 300;
+	return author == change.author;
+}
+
+
+bool operator==(Change const & l, Change const & r)
+{
+	return l.type == r.type &&
+	       l.author == r.author &&
+	       l.changetime == r.changetime;
 }
 
 
@@ -293,7 +297,7 @@ void Changes::merge()
 		if (it + 1 == table_.end())
 			break;
 
-		if (it->change == (it + 1)->change && it->range.end == (it + 1)->range.start) {
+		if (it->change.isSimilarTo((it + 1)->change) && it->range.end == (it + 1)->range.start) {
 			if (lyxerr.debugging(Debug::CHANGES)) {
 				lyxerr[Debug::CHANGES] << "  merging ranges (" << it->range.start << ", "
 					<< it->range.end << ") and (" << (it + 1)->range.start << ", "
diff --git a/src/changes.h b/src/changes.h
index 7ee38031f7..e2f0e9d4b8 100644
--- a/src/changes.h
+++ b/src/changes.h
@@ -36,6 +36,9 @@ public:
 	explicit Change(Type t, int a = 0, time_type ct = current_time())
 		: type(t), author(a), changetime(ct) {}
 
+	/// is the change similar to the given change such that both can be merged?
+	bool isSimilarTo(Change const & change);
+
 	Type type;
 
 	int author;