]> git.lyx.org Git - lyx.git/blobdiff - src/changes.C
"Inter-word Space"
[lyx.git] / src / changes.C
index 3f827db07d903ed07f3c0a311a88a0861a823261..c60357718b1ab17385541124168eec26bac65473 100644 (file)
@@ -9,34 +9,34 @@
  */
 
 #include <config.h>
-#include "changes.h" 
+
+#include "changes.h"
 #include "debug.h"
 #include "author.h"
+
 #include "support/LAssert.h"
 #include "support/LOstream.h"
+
 using std::vector;
 using std::endl;
 using lyx::pos_type;
+
 bool operator==(Change const & l, Change const & r)
 {
        return l.type == r.type && l.author == r.author
                && l.changetime == r.changetime;
 }
+
 
 bool operator!=(Change const & l, Change const & r)
 {
        return !(l == r);
 }
 
+
 bool operator==(Changes::Range const & r1, Changes::Range const & r2)
 {
-       return r1.start == r2.start && r1.end == r2.end; 
+       return r1.start == r2.start && r1.end == r2.end;
 }
 
 
@@ -44,8 +44,8 @@ bool operator!=(Changes::Range const & r1, Changes::Range const & r2)
 {
        return !(r1 == r2);
 }
+
+
 bool Changes::Range::contains(Range const & r) const
 {
        return r.start >= start && r.end <= end;
@@ -56,27 +56,27 @@ bool Changes::Range::contained(Range const & r) const
 {
        return r.contains(*this);
 }
+
 
 bool Changes::Range::contains(pos_type pos) const
 {
        return pos >= start && pos < end;
 }
 
+
 bool Changes::Range::loose_contains(pos_type pos) const
 {
        return pos >= start && pos <= end;
 }
 
+
 bool Changes::Range::intersects(Range const & r) const
 {
        return contained(r) || contains(r)
                || contains(r.start) || contains(r.end);
 }
+
+
 Changes::Changes(Change::Type type)
        : empty_type_(type)
 {
@@ -96,9 +96,11 @@ Changes::Changes(Changes const & c)
 
 void Changes::record(Change change, pos_type pos)
 {
-       lyxerr[Debug::CHANGES] << "record " << change.type
-               << " at pos " << pos << " with total "
-               << table_.size() << " changes." << endl;
+       if (lyxerr.debugging(Debug::CHANGES)) {
+               lyxerr[Debug::CHANGES] << "record " << change.type
+                       << " at pos " << pos << " with total "
+                       << table_.size() << " changes." << endl;
+       }
 
        switch (change.type) {
                case Change::INSERTED:
@@ -119,34 +121,38 @@ void Changes::set(Change change, pos_type pos)
        set(change, pos, pos + 1);
 }
 
+
 void Changes::set(Change::Type type, pos_type pos)
 {
        set(type, pos, pos + 1);
 }
 
+
 void Changes::set(Change::Type type, pos_type start, pos_type end)
 {
        set(Change(type), start, end);
 }
 
+
 void Changes::set(Change change, pos_type start, pos_type end)
 {
        ChangeTable::iterator it = table_.begin();
 
-       lyxerr[Debug::CHANGES] << "changeset of " << change.type
-               << " author " << change.author << " time " << change.changetime
-               << " in range " << start << "," << end << endl;
+       if (lyxerr.debugging(Debug::CHANGES)) {
+               lyxerr[Debug::CHANGES] << "changeset of " << change.type
+                       << " author " << change.author << " time " << change.changetime
+                       << " in range " << start << "," << end << endl;
+       }
+
        Range const new_range(start, end);
+
        // remove all sub-ranges
        for (; it != table_.end();) {
                if (new_range != it->range && it->range.contained(new_range)) {
-                       lyxerr[Debug::CHANGES] << "Removing subrange "
-                               << it->range.start << "," << it->range.end << endl;
+                       if (lyxerr.debugging(Debug::CHANGES)) {
+                               lyxerr[Debug::CHANGES] << "Removing subrange "
+                                       << it->range.start << "," << it->range.end << endl;
+                       }
                        it = table_.erase(it);
                } else {
                        ++it;
@@ -176,15 +182,19 @@ void Changes::set(Change change, pos_type start, pos_type end)
        }
 
        ChangeRange c(*it);
-       lyxerr[Debug::CHANGES] << "Using change of type " << c.change.type
-               << " over " << c.range.start << "," << c.range.end << endl;
-       // split head 
+
+       if (lyxerr.debugging(Debug::CHANGES)) {
+               lyxerr[Debug::CHANGES] << "Using change of type " << c.change.type
+                       << " over " << c.range.start << "," << c.range.end << endl;
+       }
+
+       // split head
        if (c.range.start < start) {
                it = table_.insert(it, ChangeRange(c.range.start, start, c.change));
-               lyxerr[Debug::CHANGES] << "Splitting head of type " << c.change.type
-                       << " over " << c.range.start << "," << start << endl;
+               if (lyxerr.debugging(Debug::CHANGES)) {
+                       lyxerr[Debug::CHANGES] << "Splitting head of type " << c.change.type
+                               << " over " << c.range.start << "," << start << endl;
+               }
                ++it;
        }
 
@@ -193,13 +203,15 @@ void Changes::set(Change change, pos_type start, pos_type end)
        it->range.end = end;
        it->change = change;
        lyxerr[Debug::CHANGES] << "Resetting to new change" << endl;
+
        // split tail
        if (c.range.end > end) {
                ++it;
                table_.insert(it, ChangeRange(end, c.range.end, c.change));
-               lyxerr[Debug::CHANGES] << "Splitting tail of type " << c.change.type
-                       << " over " << end << "," << c.range.end << endl;
+               if (lyxerr.debugging(Debug::CHANGES)) {
+                       lyxerr[Debug::CHANGES] << "Splitting tail of type " << c.change.type
+                               << " over " << end << "," << c.range.end << endl;
+               }
        }
 
        check();
@@ -213,13 +225,15 @@ void Changes::erase(pos_type pos)
        ChangeTable::iterator end = table_.end();
 
        bool found = false;
+
        for (; it != end; ++it) {
                Range & range(it->range);
-               lyxerr[Debug::CHANGES] << "era:Range of type " << it->change.type << " is "
-                       << it->range.start << "," << it->range.end << endl; 
+
+               if (lyxerr.debugging(Debug::CHANGES)) {
+                       lyxerr[Debug::CHANGES] << "era:Range of type " << it->change.type << " is "
+                               << it->range.start << "," << it->range.end << endl;
+               }
+
                if (range.contains(pos)) {
                        found = true;
                        --range.end;
@@ -231,7 +245,7 @@ void Changes::erase(pos_type pos)
                        --range.end;
                }
        }
-       check(); 
+       check();
        merge();
 }
 
@@ -243,12 +257,12 @@ void Changes::del(Change change, ChangeTable::size_type pos)
                set(change, pos);
                return;
        }
+
        ChangeTable::iterator it = table_.begin();
 
        for (; it != table_.end(); ++it) {
                Range & range(it->range);
+
                if (range.contains(pos)) {
                        if (it->change.type != Change::INSERTED) {
                                set(change, pos);
@@ -264,21 +278,23 @@ void Changes::del(Change change, ChangeTable::size_type pos)
        }
 }
 
+
 void Changes::add(Change change, ChangeTable::size_type pos)
 {
        ChangeTable::iterator it = table_.begin();
        ChangeTable::iterator end = table_.end();
 
        bool found = false;
+
        for (; it != end; ++it) {
                Range & range(it->range);
+
                if (!found && range.loose_contains(pos)) {
                        found = true;
-                       lyxerr[Debug::CHANGES] << "Found range of "
-                               << range.start << "," << range.end << endl; 
+                       if (lyxerr.debugging(Debug::CHANGES)) {
+                               lyxerr[Debug::CHANGES] << "Found range of "
+                                       << range.start << "," << range.end << endl;
+                       }
                        ++range.end;
                        continue;
                }
@@ -291,14 +307,15 @@ void Changes::add(Change change, ChangeTable::size_type pos)
        set(change, pos);
 }
 
+
 Change const Changes::lookupFull(pos_type pos) const
 {
        if (!table_.size()) {
-               lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
+               if (lyxerr.debugging(Debug::CHANGES))
+                       lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
                return Change(empty_type_);
        }
+
        ChangeTable::const_iterator it = table_.begin();
        ChangeTable::const_iterator end = table_.end();
 
@@ -306,20 +323,21 @@ Change const Changes::lookupFull(pos_type pos) const
                if (it->range.contains(pos))
                        return it->change;
        }
+
        check();
        lyx::Assert(0);
        return Change(Change::UNCHANGED);
 }
+
 
 Change::Type Changes::lookup(pos_type pos) const
 {
        if (!table_.size()) {
-               lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
+               if (lyxerr.debugging(Debug::CHANGES))
+                       lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
                return empty_type_;
        }
+
        ChangeTable::const_iterator it = table_.begin();
        ChangeTable::const_iterator end = table_.end();
 
@@ -327,7 +345,7 @@ Change::Type Changes::lookup(pos_type pos) const
                if (it->range.contains(pos))
                        return it->change.type;
        }
+
        check();
        lyx::Assert(0);
        return Change::UNCHANGED;
@@ -337,38 +355,45 @@ Change::Type Changes::lookup(pos_type pos) const
 bool Changes::isChange(pos_type start, pos_type end) const
 {
        if (!table_.size()) {
-               lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
+               if (lyxerr.debugging(Debug::CHANGES))
+                       lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
                return empty_type_ != Change::UNCHANGED;
        }
+
        ChangeTable::const_iterator it = table_.begin();
        ChangeTable::const_iterator itend = table_.end();
 
        for (; it != itend; ++it) {
-               lyxerr[Debug::CHANGES] << "Looking for " << start << ","
-                       << end << " in " << it->range.start << "," 
-                       << it->range.end << "of type " << it->change.type << endl; 
+               if (lyxerr.debugging(Debug::CHANGES)) {
+                       lyxerr[Debug::CHANGES] << "Looking for " << start << ","
+                               << end << " in " << it->range.start << ","
+                               << it->range.end << "of type " << it->change.type << endl;
+               }
+
                if (it->range.intersects(Range(start, end))
                        && it->change.type != Change::UNCHANGED) {
-                       lyxerr[Debug::CHANGES] << "Found intersection of "
-                               << start << "," << end << " with "
-                               << it->range.start << "," << it->range.end
-                               << " of type " << it->change.type << endl;
+                       if (lyxerr.debugging(Debug::CHANGES)) {
+                               lyxerr[Debug::CHANGES] << "Found intersection of "
+                                       << start << "," << end << " with "
+                                       << it->range.start << "," << it->range.end
+                                       << " of type " << it->change.type << endl;
+                       }
                        return true;
                }
        }
+
        return false;
 }
 
+
 bool Changes::isChangeEdited(lyx::pos_type start, lyx::pos_type end) const
 {
        if (!table_.size()) {
-               lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
+               if (lyxerr.debugging(Debug::CHANGES))
+                       lyxerr[Debug::CHANGES] << "Empty, type is " << empty_type_ << endl;
                return empty_type_ != Change::INSERTED;
        }
+
        ChangeTable::const_iterator it = table_.begin();
        ChangeTable::const_iterator itend = table_.end();
 
@@ -376,38 +401,48 @@ bool Changes::isChangeEdited(lyx::pos_type start, lyx::pos_type end) const
                if (it->range.intersects(Range(start, end ? end - 1 : 0))
                        && it->change.type != Change::INSERTED) {
                        return true;
-               } 
-       } 
+               }
+       }
        return false;
 }
 
+
 void Changes::merge()
 {
-       lyxerr[Debug::CHANGES] << "Starting merge" << endl;
+       if (lyxerr.debugging(Debug::CHANGES))
+               lyxerr[Debug::CHANGES] << "Starting merge" << endl;
+
        ChangeTable::iterator it = table_.begin();
 
        while (it != table_.end()) {
-               lyxerr[Debug::CHANGES] << "Range of type " << it->change.type << " is "
-                       << it->range.start << "," << it->range.end << endl; 
+               if (lyxerr.debugging(Debug::CHANGES)) {
+                       lyxerr[Debug::CHANGES] << "Range of type " << it->change.type << " is "
+                               << it->range.start << "," << it->range.end << endl;
+               }
+
                if (it->range.start == it->range.end) {
-                       lyxerr[Debug::CHANGES] << "Removing empty range for pos "
-                               << it->range.start << endl;
+                       if (lyxerr.debugging(Debug::CHANGES)) {
+                               lyxerr[Debug::CHANGES] << "Removing empty range for pos "
+                                       << it->range.start << endl;
+                       }
+
                        table_.erase(it);
                        // start again
                        it = table_.begin();
                        continue;
                }
-                        
+
                if (it + 1 == table_.end())
                        break;
+
                if (it->change == (it + 1)->change) {
-                       lyxerr[Debug::CHANGES] << "Merging equal ranges "
-                               << it->range.start << "," << it->range.end
-                               << " and " << (it + 1)->range.start << ","
-                               << (it + 1)->range.end << endl; 
+                       if (lyxerr.debugging(Debug::CHANGES)) {
+                               lyxerr[Debug::CHANGES] << "Merging equal ranges "
+                                       << it->range.start << "," << it->range.end
+                                       << " and " << (it + 1)->range.start << ","
+                                       << (it + 1)->range.end << endl;
+                       }
+
                        (it + 1)->range.start = it->range.start;
                        table_.erase(it);
                        // start again
@@ -417,24 +452,27 @@ void Changes::merge()
 
                ++it;
        }
+
        lyxerr[Debug::CHANGES] << "Merge ended" << endl;
        check();
 }
 
+
 void Changes::check() const
 {
        ChangeTable::const_iterator it = table_.begin();
        ChangeTable::const_iterator end = table_.end();
 
        bool dont_assert(true);
+
        lyxerr[Debug::CHANGES] << "Changelist:" << endl;
        for (; it != end; ++it) {
-               lyxerr[Debug::CHANGES] << "Range of type " << it->change.type << " is "
-                       << it->range.start << "," << it->range.end << " author "
-                       << it->change.author << " time " << it->change.changetime << endl; 
+               if (lyxerr.debugging(Debug::CHANGES)) {
+                       lyxerr[Debug::CHANGES] << "Range of type " << it->change.type << " is "
+                               << it->range.start << "," << it->range.end << " author "
+                               << it->change.author << " time " << it->change.changetime << endl;
+               }
+
                if (it + 1 == end)
                        break;
 
@@ -443,13 +481,16 @@ void Changes::check() const
                if (range.end != next.start)
                        dont_assert = false;
        }
-       lyxerr[Debug::CHANGES] << "End" << endl; 
+
+       if (lyxerr.debugging(Debug::CHANGES))
+               lyxerr[Debug::CHANGES] << "End" << endl;
+
        lyx::Assert(dont_assert);
 }
 
+
 int Changes::latexMarkChange(std::ostream & os, Change::Type old, Change::Type change)
-{ 
+{
        if (old == change)
                return 0;
 
@@ -457,14 +498,14 @@ int Changes::latexMarkChange(std::ostream & os, Change::Type old, Change::Type c
        string const end("\\changeend{}");
        string const son("\\overstrikeon{}");
        string const soff("\\overstrikeoff{}");
+
        int column = 0;
+
        if (old == Change::DELETED) {
                os << soff;
                column += soff.length();
        }
+
        switch (change) {
                case Change::UNCHANGED:
                        os << end;
@@ -487,7 +528,7 @@ int Changes::latexMarkChange(std::ostream & os, Change::Type old, Change::Type c
                        }
                        break;
        }
+
        return column;
 }
 
@@ -499,7 +540,7 @@ void Changes::lyxMarkChange(std::ostream & os, int & column, lyx::time_type curt
                return;
 
        column = 0;
+
        switch (change.type) {
                case Change::UNCHANGED:
                        os << "\n\\change_unchanged\n";
@@ -511,7 +552,7 @@ void Changes::lyxMarkChange(std::ostream & os, int & column, lyx::time_type curt
                                t = curtime;
                        os << "\n\\change_deleted " << change.author
                                << " " << t << "\n";
+
                        break;
                }