src/Changes.cpp

   1 /**
   2  * \file Changes.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Levon
   7  * \author Michael Gerz
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  *
  11  * Record changes in a paragraph.
  12  */
  13
  14 #include <config.h>
  15
  16 #include "Changes.h"
  17 #include "Author.h"
  18 #include "Buffer.h"
  19 #include "BufferParams.h"
  20 #include "Encoding.h"
  21 #include "LaTeXFeatures.h"
  22 #include "OutputParams.h"
  23 #include "Paragraph.h"
  24 #include "TocBackend.h"
  25
  26 #include "support/debug.h"
  27 #include "support/gettext.h"
  28 #include "support/lassert.h"
  29 #include "support/lstrings.h"
  30
  31 #include "frontends/alert.h"
  32
  33 #include <ostream>
  34
  35 using namespace std;
  36
  37 namespace lyx {
  38
  39 /*
  40  * Class Change has a changetime field that specifies the exact time at which
  41  * a specific change was made. The change time is used as a guidance for the
  42  * user while editing his document. Presently, it is not considered for LaTeX
  43  * export.
  44  * When merging two adjacent changes, the changetime is not considered,
  45  * only the equality of the change type and author is checked (in method
  46  * isSimilarTo(...)). If two changes are in fact merged (in method merge()),
  47  * the later change time is preserved.
  48  */
  49
  50 bool Change::isSimilarTo(Change const & change) const
  51 {
  52         if (type != change.type)
  53                 return false;
  54
  55         if (type == Change::UNCHANGED)
  56                 return true;
  57
  58         return author == change.author;
  59 }
  60
  61
  62 Color Change::color() const
  63 {
  64         Color color = Color_none;
  65         switch (author % 5) {
  66                 case 0:
  67                         color = Color_changedtextauthor1;
  68                         break;
  69                 case 1:
  70                         color = Color_changedtextauthor2;
  71                         break;
  72                 case 2:
  73                         color = Color_changedtextauthor3;
  74                         break;
  75                 case 3:
  76                         color = Color_changedtextauthor4;
  77                         break;
  78                 case 4:
  79                         color = Color_changedtextauthor5;
  80                         break;
  81         }
  82
  83         if (deleted())
  84                 color.mergeColor = Color_deletedtextmodifier;
  85
  86         return color;
  87 }
  88
  89
  90 bool operator==(Change const & l, Change const & r)
  91 {
  92         if (l.type != r.type)
  93                 return false;
  94
  95         // two changes of type UNCHANGED are always equal
  96         if (l.type == Change::UNCHANGED)
  97                 return true;
  98
  99         return l.author == r.author && l.changetime == r.changetime;
 100 }
 101
 102
 103 bool operator!=(Change const & l, Change const & r)
 104 {
 105         return !(l == r);
 106 }
 107
 108
 109 bool operator==(Changes::Range const & r1, Changes::Range const & r2)
 110 {
 111         return r1.start == r2.start && r1.end == r2.end;
 112 }
 113
 114
 115 bool operator!=(Changes::Range const & r1, Changes::Range const & r2)
 116 {
 117         return !(r1 == r2);
 118 }
 119
 120
 121 bool Changes::Range::intersects(Range const & r) const
 122 {
 123         return r.start < end && r.end > start; // end itself is not in the range!
 124 }
 125
 126
 127 void Changes::set(Change const & change, pos_type const pos)
 128 {
 129         set(change, pos, pos + 1);
 130 }
 131
 132
 133 void Changes::set(Change const & change, pos_type const start, pos_type const end)
 134 {
 135         if (change.type != Change::UNCHANGED) {
 136                 LYXERR(Debug::CHANGES, "setting change (type: " << change.type
 137                         << ", author: " << change.author
 138                         << ", time: " << long(change.changetime)
 139                         << ") in range (" << start << ", " << end << ")");
 140         }
 141
 142         Range const newRange(start, end);
 143
 144         ChangeTable::iterator it = table_.begin();
 145
 146         for (; it != table_.end(); ) {
 147                 // current change starts like or follows new change
 148                 if (it->range.start >= start) {
 149                         break;
 150                 }
 151
 152                 // new change intersects with existing change
 153                 if (it->range.end > start) {
 154                         pos_type oldEnd = it->range.end;
 155                         it->range.end = start;
 156
 157                         LYXERR(Debug::CHANGES, "  cutting tail of type " << it->change.type
 158                                 << " resulting in range (" << it->range.start << ", "
 159                                 << it->range.end << ")");
 160
 161                         ++it;
 162                         if (oldEnd >= end) {
 163                                 LYXERR(Debug::CHANGES, "  inserting tail in range ("
 164                                         << end << ", " << oldEnd << ")");
 165                                 it = table_.insert(it, ChangeRange((it-1)->change, Range(end, oldEnd)));
 166                         }
 167                         continue;
 168                 }
 169
 170                 ++it;
 171         }
 172
 173         if (change.type != Change::UNCHANGED) {
 174                 LYXERR(Debug::CHANGES, "  inserting change");
 175                 it = table_.insert(it, ChangeRange(change, Range(start, end)));
 176                 ++it;
 177         }
 178
 179         for (; it != table_.end(); ) {
 180                 // new change 'contains' existing change
 181                 if (newRange.contains(it->range)) {
 182                         LYXERR(Debug::CHANGES, "  removing subrange ("
 183                                 << it->range.start << ", " << it->range.end << ")");
 184                         it = table_.erase(it);
 185                         continue;
 186                 }
 187
 188                 // new change precedes existing change
 189                 if (it->range.start >= end)
 190                         break;
 191
 192                 // new change intersects with existing change
 193                 it->range.start = end;
 194                 LYXERR(Debug::CHANGES, "  cutting head of type "
 195                         << it->change.type << " resulting in range ("
 196                         << end << ", " << it->range.end << ")");
 197                 break; // no need for another iteration
 198         }
 199
 200         merge();
 201 }
 202
 203
 204 void Changes::erase(pos_type const pos)
 205 {
 206         LYXERR(Debug::CHANGES, "Erasing change at position " << pos);
 207
 208         ChangeTable::iterator it = table_.begin();
 209         ChangeTable::iterator end = table_.end();
 210
 211         for (; it != end; ++it) {
 212                 // range (pos,pos+x) becomes (pos,pos+x-1)
 213                 if (it->range.start > pos)
 214                         --(it->range.start);
 215                 // range (pos-x,pos) stays (pos-x,pos)
 216                 if (it->range.end > pos)
 217                         --(it->range.end);
 218         }
 219
 220         merge();
 221 }
 222
 223
 224 void Changes::insert(Change const & change, lyx::pos_type pos)
 225 {
 226         if (change.type != Change::UNCHANGED) {
 227                 LYXERR(Debug::CHANGES, "Inserting change of type " << change.type
 228                         << " at position " << pos);
 229         }
 230
 231         ChangeTable::iterator it = table_.begin();
 232         ChangeTable::iterator end = table_.end();
 233
 234         for (; it != end; ++it) {
 235                 // range (pos,pos+x) becomes (pos+1,pos+x+1)
 236                 if (it->range.start >= pos)
 237                         ++(it->range.start);
 238
 239                 // range (pos-x,pos) stays as it is
 240                 if (it->range.end > pos)
 241                         ++(it->range.end);
 242         }
 243
 244         set(change, pos, pos + 1); // set will call merge
 245 }
 246
 247
 248 Change const & Changes::lookup(pos_type const pos) const
 249 {
 250         static Change const noChange = Change(Change::UNCHANGED);
 251
 252         ChangeTable::const_iterator it = table_.begin();
 253         ChangeTable::const_iterator const end = table_.end();
 254
 255         for (; it != end; ++it) {
 256                 if (it->range.contains(pos))
 257                         return it->change;
 258         }
 259
 260         return noChange;
 261 }
 262
 263
 264 bool Changes::isDeleted(pos_type start, pos_type end) const
 265 {
 266         ChangeTable::const_iterator it = table_.begin();
 267         ChangeTable::const_iterator const itend = table_.end();
 268
 269         for (; it != itend; ++it) {
 270                 if (it->range.contains(Range(start, end))) {
 271                         LYXERR(Debug::CHANGES, "range ("
 272                                 << start << ", " << end << ") fully contains ("
 273                                 << it->range.start << ", " << it->range.end
 274                                 << ") of type " << it->change.type);
 275                         return it->change.type == Change::DELETED;
 276                 }
 277         }
 278         return false;
 279 }
 280
 281
 282 bool Changes::isChanged(pos_type const start, pos_type const end) const
 283 {
 284         ChangeTable::const_iterator it = table_.begin();
 285         ChangeTable::const_iterator const itend = table_.end();
 286
 287         for (; it != itend; ++it) {
 288                 if (it->range.intersects(Range(start, end))) {
 289                         LYXERR(Debug::CHANGES, "found intersection of range ("
 290                                 << start << ", " << end << ") with ("
 291                                 << it->range.start << ", " << it->range.end
 292                                 << ") of type " << it->change.type);
 293                         return true;
 294                 }
 295         }
 296         return false;
 297 }
 298
 299
 300 void Changes::merge()
 301 {
 302         ChangeTable::iterator it = table_.begin();
 303
 304         while (it != table_.end()) {
 305                 LYXERR(Debug::CHANGES, "found change of type " << it->change.type
 306                         << " and range (" << it->range.start << ", " << it->range.end
 307                         << ")");
 308
 309                 if (it->range.start == it->range.end) {
 310                         LYXERR(Debug::CHANGES, "removing empty range for pos "
 311                                 << it->range.start);
 312
 313                         table_.erase(it);
 314                         // start again
 315                         it = table_.begin();
 316                         continue;
 317                 }
 318
 319                 if (it + 1 == table_.end())
 320                         break;
 321
 322                 if (it->change.isSimilarTo((it + 1)->change)
 323                     && it->range.end == (it + 1)->range.start) {
 324                         LYXERR(Debug::CHANGES, "merging ranges (" << it->range.start << ", "
 325                                 << it->range.end << ") and (" << (it + 1)->range.start << ", "
 326                                 << (it + 1)->range.end << ")");
 327
 328                         (it + 1)->range.start = it->range.start;
 329                         (it + 1)->change.changetime = max(it->change.changetime,
 330                                                           (it + 1)->change.changetime);
 331                         table_.erase(it);
 332                         // start again
 333                         it = table_.begin();
 334                         continue;
 335                 }
 336
 337                 ++it;
 338         }
 339 }
 340
 341
 342 namespace {
 343
 344 docstring getLaTeXMarkup(docstring const & macro, docstring const & author,
 345                          docstring const & chgTime,
 346                          OutputParams const & runparams)
 347 {
 348         if (macro.empty())
 349                 return docstring();
 350
 351         static docstring warned_author = docstring();
 352         docstring uncodable_author = warned_author;
 353         odocstringstream ods;
 354
 355         ods << macro;
 356         // convert utf8 author name to something representable
 357         // in the current encoding
 358         pair<docstring, docstring> author_latexed =
 359                 runparams.encoding->latexString(author, runparams.dryrun);
 360         if (!author_latexed.second.empty()) {
 361                 LYXERR0("Omitting uncodable characters '"
 362                         << author_latexed.second
 363                         << "' in change author name!");
 364                 uncodable_author = author;
 365         }
 366         ods << author_latexed.first << "}{" << chgTime << "}{";
 367
 368         // warn user (once) if we found uncodable glyphs.
 369         if (uncodable_author != warned_author) {
 370                 frontend::Alert::warning(_("Uncodable character in author name"),
 371                                 support::bformat(_("The author name '%1$s',\n"
 372                                   "used for change tracking, contains the following glyphs that\n"
 373                                   "cannot be represented in the current encoding: %2$s.\n"
 374                                   "These glyphs will be omitted in the exported LaTeX file.\n\n"
 375                                   "Choose an appropriate document encoding (such as utf8)\n"
 376                                   "or change the spelling of the author name."),
 377                                 uncodable_author, author_latexed.second));
 378                 warned_author = uncodable_author;
 379         }
 380
 381         return ods.str();
 382 }
 383
 384 } //namespace anon
 385
 386
 387 int Changes::latexMarkChange(otexstream & os, BufferParams const & bparams,
 388                              Change const & oldChange, Change const & change,
 389                              OutputParams const & runparams)
 390 {
 391         if (!bparams.outputChanges || oldChange == change)
 392                 return 0;
 393
 394         int column = 0;
 395
 396         if (oldChange.type != Change::UNCHANGED) {
 397                 // close \lyxadded or \lyxdeleted
 398                 os << '}';
 399                 column++;
 400         }
 401
 402         docstring chgTime;
 403         chgTime += asctime(gmtime(&change.changetime));
 404         // remove trailing '\n'
 405         chgTime.erase(chgTime.end() - 1);
 406
 407         docstring macro_beg;
 408         if (change.type == Change::DELETED)
 409                 macro_beg = from_ascii("\\lyxdeleted{");
 410         else if (change.type == Change::INSERTED)
 411                 macro_beg = from_ascii("\\lyxadded{");
 412
 413         docstring str = getLaTeXMarkup(macro_beg,
 414                                        bparams.authors().get(change.author).name(),
 415                                        chgTime, runparams);
 416
 417         os << str;
 418         column += str.size();
 419
 420         return column;
 421 }
 422
 423
 424 void Changes::lyxMarkChange(ostream & os, BufferParams const & bparams, int & column,
 425                             Change const & old, Change const & change)
 426 {
 427         if (old == change)
 428                 return;
 429
 430         column = 0;
 431
 432         int const buffer_id = bparams.authors().get(change.author).bufferId();
 433
 434         switch (change.type) {
 435                 case Change::UNCHANGED:
 436                         os << "\n\\change_unchanged\n";
 437                         break;
 438
 439                 case Change::DELETED:
 440                         os << "\n\\change_deleted " << buffer_id
 441                                 << " " << change.changetime << "\n";
 442                         break;
 443
 444                 case Change::INSERTED:
 445                         os << "\n\\change_inserted " << buffer_id
 446                                 << " " << change.changetime << "\n";
 447                         break;
 448         }
 449 }
 450
 451
 452 void Changes::checkAuthors(AuthorList const & authorList)
 453 {
 454         ChangeTable::const_iterator it = table_.begin();
 455         ChangeTable::const_iterator endit = table_.end();
 456         for ( ; it != endit ; ++it)
 457                 if (it->change.type != Change::UNCHANGED)
 458                         authorList.get(it->change.author).setUsed(true);
 459 }
 460
 461
 462 void Changes::addToToc(DocIterator const & cdit, Buffer const & buffer,
 463         bool output_active) const
 464 {
 465         if (table_.empty())
 466                 return;
 467
 468         Toc & change_list = buffer.tocBackend().toc("change");
 469         AuthorList const & author_list = buffer.params().authors();
 470         DocIterator dit = cdit;
 471
 472         ChangeTable::const_iterator it = table_.begin();
 473         ChangeTable::const_iterator const itend = table_.end();
 474         for (; it != itend; ++it) {
 475                 docstring str;
 476                 switch (it->change.type) {
 477                 case Change::UNCHANGED:
 478                         continue;
 479                 case Change::DELETED:
 480                         // 0x2702 is a scissors symbol in the Dingbats unicode group.
 481                         str.push_back(0x2702);
 482                         break;
 483                 case Change::INSERTED:
 484                         // 0x270d is the hand writting symbol in the Dingbats unicode group.
 485                         str.push_back(0x270d); break;
 486                 }
 487                 dit.pos() = it->range.start;
 488                 Paragraph const & par = dit.paragraph();
 489                 str += " " + par.asString(it->range.start, min(par.size(), it->range.end));
 490                 if (it->range.end > par.size())
 491                         // the end of paragraph symbol from the Punctuation group
 492                         str.push_back(0x204B);
 493                 docstring const & author = author_list.get(it->change.author).name();
 494                 Toc::iterator it = change_list.item(0, author);
 495                 if (it == change_list.end()) {
 496                         change_list.push_back(TocItem(dit, 0, author, output_active));
 497                         change_list.push_back(TocItem(dit, 1, str, output_active,
 498                                 support::wrapParas(str, 4)));
 499                         continue;
 500                 }
 501                 for (++it; it != change_list.end(); ++it) {
 502                         if (it->depth() == 0 && it->str() != author)
 503                                 break;
 504                 }
 505                 change_list.insert(it, TocItem(dit, 1, str, output_active,
 506                         support::wrapParas(str, 4)));
 507         }
 508 }
 509
 510 } // namespace lyx