X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FChanges.cpp;h=0d464d8fa26912b47e2dd74c78f2e0c70394366c;hb=0c7bd9a57f2a308bb9659200eda3b7e45f8d5d3c;hp=fec558e56ea77d893579e0e55425e67a8eb18de8;hpb=038cc706500567634c68d71342e8be54cf0e81bd;p=lyx.git diff --git a/src/Changes.cpp b/src/Changes.cpp index fec558e56e..0d464d8fa2 100644 --- a/src/Changes.cpp +++ b/src/Changes.cpp @@ -14,20 +14,35 @@ #include #include "Changes.h" -#include "debug.h" #include "Author.h" +#include "Buffer.h" #include "BufferParams.h" +#include "Encoding.h" #include "LaTeXFeatures.h" +#include "MetricsInfo.h" +#include "OutputParams.h" +#include "Paragraph.h" +#include "texstream.h" +#include "TocBackend.h" -#include +#include "support/debug.h" +#include "support/gettext.h" +#include "support/lassert.h" +#include "support/lstrings.h" +#include "support/mutex.h" +#include "frontends/alert.h" +#include "frontends/FontMetrics.h" +#include "frontends/Painter.h" + +#include + +using namespace std; namespace lyx { -using std::abs; -using std::endl; -using std::string; -using std::max; +using frontend::Painter; +using frontend::FontMetrics; /* * Class Change has a changetime field that specifies the exact time at which @@ -37,36 +52,59 @@ using std::max; * 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. + * the later change time is preserved. */ -bool Change::isSimilarTo(Change const & change) +bool Change::isSimilarTo(Change const & change) const { - if (type != change.type) { + if (type != change.type) return false; - } - if (type == Change::UNCHANGED) { + if (type == Change::UNCHANGED) return true; - } return author == change.author; } +Color Change::color() const +{ + Color color = Color_none; + switch (author % 5) { + case 0: + color = Color_changedtextauthor1; + break; + case 1: + color = Color_changedtextauthor2; + break; + case 2: + color = Color_changedtextauthor3; + break; + case 3: + color = Color_changedtextauthor4; + break; + case 4: + color = Color_changedtextauthor5; + break; + } + + if (deleted()) + color.mergeColor = Color_deletedtextmodifier; + + return color; +} + + bool operator==(Change const & l, Change const & r) { - if (l.type != r.type) { + if (l.type != r.type) return false; - } // two changes of type UNCHANGED are always equal - if (l.type == Change::UNCHANGED) { + if (l.type == Change::UNCHANGED) return true; - } - - return l.author == r.author && - l.changetime == r.changetime; + + return l.author == r.author && l.changetime == r.changetime; } @@ -103,9 +141,12 @@ void Changes::set(Change const & change, pos_type const pos) void Changes::set(Change const & change, pos_type const start, pos_type const end) { if (change.type != Change::UNCHANGED) { - LYXERR(Debug::CHANGES) << "setting change (type: " << change.type - << ", author: " << change.author << ", time: " << change.changetime - << ") in range (" << start << ", " << end << ")" << endl; + LYXERR(Debug::CHANGES, "setting change (type: " << change.type + << ", author: " << change.author + << ", time: " << long(change.changetime) + << ") in range (" << start << ", " << end << ")"); + if (!isChanged()) + is_update_required_ = true; } Range const newRange(start, end); @@ -123,14 +164,14 @@ void Changes::set(Change const & change, pos_type const start, pos_type const en pos_type oldEnd = it->range.end; it->range.end = start; - LYXERR(Debug::CHANGES) << " cutting tail of type " << it->change.type + LYXERR(Debug::CHANGES, " cutting tail of type " << it->change.type << " resulting in range (" << it->range.start << ", " - << it->range.end << ")" << endl; + << it->range.end << ")"); ++it; if (oldEnd >= end) { - LYXERR(Debug::CHANGES) << " inserting tail in range (" - << end << ", " << oldEnd << ")" << endl; + LYXERR(Debug::CHANGES, " inserting tail in range (" + << end << ", " << oldEnd << ")"); it = table_.insert(it, ChangeRange((it-1)->change, Range(end, oldEnd))); } continue; @@ -140,7 +181,7 @@ void Changes::set(Change const & change, pos_type const start, pos_type const en } if (change.type != Change::UNCHANGED) { - LYXERR(Debug::CHANGES) << " inserting change" << endl; + LYXERR(Debug::CHANGES, " inserting change"); it = table_.insert(it, ChangeRange(change, Range(start, end))); ++it; } @@ -148,22 +189,21 @@ void Changes::set(Change const & change, pos_type const start, pos_type const en for (; it != table_.end(); ) { // new change 'contains' existing change if (newRange.contains(it->range)) { - LYXERR(Debug::CHANGES) << " removing subrange (" - << it->range.start << ", " << it->range.end << ")" << endl; + LYXERR(Debug::CHANGES, " removing subrange (" + << it->range.start << ", " << it->range.end << ")"); it = table_.erase(it); continue; } // new change precedes existing change - if (it->range.start >= end) { + if (it->range.start >= end) break; - } // new change intersects with existing change it->range.start = end; - LYXERR(Debug::CHANGES) << " cutting head of type " + LYXERR(Debug::CHANGES, " cutting head of type " << it->change.type << " resulting in range (" - << end << ", " << it->range.end << ")" << endl; + << end << ", " << it->range.end << ")"); break; // no need for another iteration } @@ -173,20 +213,18 @@ void Changes::set(Change const & change, pos_type const start, pos_type const en void Changes::erase(pos_type const pos) { - LYXERR(Debug::CHANGES) << "Erasing change at position " << pos << endl; + LYXERR(Debug::CHANGES, "Erasing change at position " << pos); ChangeTable::iterator it = table_.begin(); ChangeTable::iterator end = table_.end(); for (; it != end; ++it) { // range (pos,pos+x) becomes (pos,pos+x-1) - if (it->range.start > pos) { + if (it->range.start > pos) --(it->range.start); - } // range (pos-x,pos) stays (pos-x,pos) - if (it->range.end > pos) { + if (it->range.end > pos) --(it->range.end); - } } merge(); @@ -196,8 +234,8 @@ void Changes::erase(pos_type const pos) void Changes::insert(Change const & change, lyx::pos_type pos) { if (change.type != Change::UNCHANGED) { - LYXERR(Debug::CHANGES) << "Inserting change of type " << change.type - << " at position " << pos << endl; + LYXERR(Debug::CHANGES, "Inserting change of type " << change.type + << " at position " << pos); } ChangeTable::iterator it = table_.begin(); @@ -205,14 +243,12 @@ void Changes::insert(Change const & change, lyx::pos_type pos) for (; it != end; ++it) { // range (pos,pos+x) becomes (pos+1,pos+x+1) - if (it->range.start >= pos) { + if (it->range.start >= pos) ++(it->range.start); - } // range (pos-x,pos) stays as it is - if (it->range.end > pos) { + if (it->range.end > pos) ++(it->range.end); - } } set(change, pos, pos + 1); // set will call merge @@ -222,7 +258,7 @@ void Changes::insert(Change const & change, lyx::pos_type pos) Change const & Changes::lookup(pos_type const pos) const { static Change const noChange = Change(Change::UNCHANGED); - + ChangeTable::const_iterator it = table_.begin(); ChangeTable::const_iterator const end = table_.end(); @@ -235,6 +271,24 @@ Change const & Changes::lookup(pos_type const pos) const } +bool Changes::isDeleted(pos_type start, pos_type end) const +{ + ChangeTable::const_iterator it = table_.begin(); + ChangeTable::const_iterator const itend = table_.end(); + + for (; it != itend; ++it) { + if (it->range.contains(Range(start, end))) { + LYXERR(Debug::CHANGES, "range (" + << start << ", " << end << ") fully contains (" + << it->range.start << ", " << it->range.end + << ") of type " << it->change.type); + return it->change.type == Change::DELETED; + } + } + return false; +} + + bool Changes::isChanged(pos_type const start, pos_type const end) const { ChangeTable::const_iterator it = table_.begin(); @@ -242,10 +296,10 @@ bool Changes::isChanged(pos_type const start, pos_type const end) const for (; it != itend; ++it) { if (it->range.intersects(Range(start, end))) { - LYXERR(Debug::CHANGES) << "found intersection of range (" + LYXERR(Debug::CHANGES, "found intersection of range (" << start << ", " << end << ") with (" << it->range.start << ", " << it->range.end - << ") of type " << it->change.type << endl; + << ") of type " << it->change.type); return true; } } @@ -253,20 +307,34 @@ bool Changes::isChanged(pos_type const start, pos_type const end) const } +bool Changes::isChanged() const +{ + ChangeTable::const_iterator it = table_.begin(); + ChangeTable::const_iterator const itend = table_.end(); + for (; it != itend; ++it) { + if (it->change.changed()) + return true; + } + return false; +} + + void Changes::merge() { + bool merged = false; ChangeTable::iterator it = table_.begin(); while (it != table_.end()) { - LYXERR(Debug::CHANGES) << "found change of type " << it->change.type + LYXERR(Debug::CHANGES, "found change of type " << it->change.type << " and range (" << 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; + LYXERR(Debug::CHANGES, "removing empty range for pos " + << it->range.start); table_.erase(it); + merged = true; // start again it = table_.begin(); continue; @@ -275,15 +343,17 @@ void Changes::merge() if (it + 1 == table_.end()) break; - if (it->change.isSimilarTo((it + 1)->change) && it->range.end == (it + 1)->range.start) { - LYXERR(Debug::CHANGES) << "merging ranges (" << it->range.start << ", " + if (it->change.isSimilarTo((it + 1)->change) + && it->range.end == (it + 1)->range.start) { + LYXERR(Debug::CHANGES, "merging ranges (" << it->range.start << ", " << it->range.end << ") and (" << (it + 1)->range.start << ", " - << (it + 1)->range.end << ")" << endl; + << (it + 1)->range.end << ")"); (it + 1)->range.start = it->range.start; (it + 1)->change.changetime = max(it->change.changetime, - (it + 1)->change.changetime); + (it + 1)->change.changetime); table_.erase(it); + merged = true; // start again it = table_.begin(); continue; @@ -291,45 +361,102 @@ void Changes::merge() ++it; } + if (merged && !isChanged()) + is_update_required_ = true; +} + + +namespace { + +docstring getLaTeXMarkup(docstring const & macro, docstring const & author, + docstring const & chgTime, + OutputParams const & runparams) +{ + if (macro.empty()) + return docstring(); + + docstring uncodable_author; + odocstringstream ods; + + ods << macro; + // convert utf8 author name to something representable + // in the current encoding + pair author_latexed = + runparams.encoding->latexString(author, runparams.dryrun); + if (!author_latexed.second.empty()) { + LYXERR0("Omitting uncodable characters '" + << author_latexed.second + << "' in change author name!"); + uncodable_author = author; + } + ods << author_latexed.first << "}{" << chgTime << "}{"; + + // warn user (once) if we found uncodable glyphs. + if (!uncodable_author.empty()) { + static std::set warned_authors; + static Mutex warned_mutex; + Mutex::Locker locker(&warned_mutex); + if (warned_authors.find(uncodable_author) == warned_authors.end()) { + frontend::Alert::warning(_("Uncodable character in author name"), + support::bformat(_("The author name '%1$s',\n" + "used for change tracking, contains the following glyphs that\n" + "cannot be represented in the current encoding: %2$s.\n" + "These glyphs will be omitted in the exported LaTeX file.\n\n" + "Choose an appropriate document encoding (such as utf8)\n" + "or change the spelling of the author name."), + uncodable_author, author_latexed.second)); + warned_authors.insert(uncodable_author); + } + } + + return ods.str(); } +} //namespace anon + -int Changes::latexMarkChange(odocstream & os, BufferParams const & bparams, - Change const & oldChange, Change const & change) +int Changes::latexMarkChange(otexstream & os, BufferParams const & bparams, + Change const & oldChange, Change const & change, + OutputParams const & runparams) { - if (!bparams.outputChanges || oldChange == change) + if (!bparams.output_changes || oldChange == change) return 0; int column = 0; if (oldChange.type != Change::UNCHANGED) { - os << '}'; // close \lyxinserted or \lyxdeleted + // close \lyxadded or \lyxdeleted + os << '}'; column++; + if (oldChange.type == Change::DELETED) + --runparams.inulemcmd; } docstring chgTime; - chgTime += ctime(&change.changetime); - chgTime.erase(chgTime.end() - 1); // remove trailing '\n' + chgTime += asctime(gmtime(&change.changetime)); + // remove trailing '\n' + chgTime.erase(chgTime.end() - 1); + docstring macro_beg; if (change.type == Change::DELETED) { - docstring str = "\\lyxdeleted{" + - bparams.authors().get(change.author).name() + "}{" + - chgTime + "}{"; - os << str; - column += str.size(); - } else if (change.type == Change::INSERTED) { - docstring str = "\\lyxinserted{" + - bparams.authors().get(change.author).name() + "}{" + - chgTime + "}{"; - os << str; - column += str.size(); + macro_beg = from_ascii("\\lyxdeleted{"); + ++runparams.inulemcmd; } + else if (change.type == Change::INSERTED) + macro_beg = from_ascii("\\lyxadded{"); + + docstring str = getLaTeXMarkup(macro_beg, + bparams.authors().get(change.author).name(), + chgTime, runparams); + + os << str; + column += str.size(); return column; } -void Changes::lyxMarkChange(std::ostream & os, int & column, +void Changes::lyxMarkChange(ostream & os, BufferParams const & bparams, int & column, Change const & old, Change const & change) { if (old == change) @@ -337,22 +464,133 @@ void Changes::lyxMarkChange(std::ostream & os, int & column, column = 0; + int const buffer_id = bparams.authors().get(change.author).bufferId(); + switch (change.type) { case Change::UNCHANGED: os << "\n\\change_unchanged\n"; break; - case Change::DELETED: { - os << "\n\\change_deleted " << change.author + case Change::DELETED: + os << "\n\\change_deleted " << buffer_id << " " << change.changetime << "\n"; break; - } - case Change::INSERTED: { - os << "\n\\change_inserted " << change.author + case Change::INSERTED: + os << "\n\\change_inserted " << buffer_id << " " << change.changetime << "\n"; break; + } +} + + +void Changes::checkAuthors(AuthorList const & authorList) +{ + ChangeTable::const_iterator it = table_.begin(); + ChangeTable::const_iterator endit = table_.end(); + for ( ; it != endit ; ++it) + if (it->change.type != Change::UNCHANGED) + authorList.get(it->change.author).setUsed(true); +} + + +void Changes::addToToc(DocIterator const & cdit, Buffer const & buffer, + bool output_active) const +{ + if (table_.empty()) + return; + + shared_ptr change_list = buffer.tocBackend().toc("change"); + AuthorList const & author_list = buffer.params().authors(); + DocIterator dit = cdit; + + ChangeTable::const_iterator it = table_.begin(); + ChangeTable::const_iterator const itend = table_.end(); + for (; it != itend; ++it) { + docstring str; + switch (it->change.type) { + case Change::UNCHANGED: + continue; + case Change::DELETED: + // ✂ U+2702 BLACK SCISSORS + str.push_back(0x2702); + break; + case Change::INSERTED: + // ✍ U+270D WRITING HAND + str.push_back(0x270d); + break; + } + dit.pos() = it->range.start; + Paragraph const & par = dit.paragraph(); + str += " " + par.asString(it->range.start, min(par.size(), it->range.end)); + if (it->range.end > par.size()) + // ¶ U+00B6 PILCROW SIGN + str.push_back(0xb6); + docstring const & author = author_list.get(it->change.author).name(); + Toc::iterator it = TocBackend::findItem(*change_list, 0, author); + if (it == change_list->end()) { + change_list->push_back(TocItem(dit, 0, author, true)); + change_list->push_back(TocItem(dit, 1, str, output_active)); + continue; } + for (++it; it != change_list->end(); ++it) { + if (it->depth() == 0 && it->str() != author) + break; + } + change_list->insert(it, TocItem(dit, 1, str, output_active)); + } +} + + +void Changes::updateBuffer(Buffer const & buf) +{ + is_update_required_ = false; + if (!buf.areChangesPresent() && isChanged()) + buf.setChangesPresent(true); +} + + +void Change::paintCue(PainterInfo & pi, double const x1, double const y, + double const x2, FontInfo const & font) const +{ + if (!changed()) + return; + // Calculate 1/3 height of font + FontMetrics const & fm = theFontMetrics(font); + double const y_bar = deleted() ? y - fm.maxAscent() / 3 + : y + 2 * pi.base.solidLineOffset() + pi.base.solidLineThickness(); + pi.pain.line(int(x1), int(y_bar), int(x2), int(y_bar), color(), + Painter::line_solid, pi.base.solidLineThickness()); +} + + +void Change::paintCue(PainterInfo & pi, double const x1, double const y1, + double const x2, double const y2) const +{ + /* + * y1 / + * / + * / + * / + * / + * y2 /_____ + * x1 x2 + */ + switch(type) { + case UNCHANGED: + return; + case INSERTED: + pi.pain.line(int(x1), int(y2) + 1, int(x2), int(y2) + 1, + color(), Painter::line_solid, + pi.base.solidLineThickness()); + return; + case DELETED: + // FIXME: we cannot use antialias since we keep drawing on the same + // background with the current painting mechanism. + pi.pain.line(int(x1), int(y2), int(x2), int(y1), + color(), Painter::line_solid_aliased, + pi.base.solidLineThickness()); + return; } }