X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=426862c246e3f8d04151b46d8ac03ef240cc1268;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=c9b7b01f80e3fbf025f1b16cdfbc20e6100f9878;hpb=51ed92d70c5020ee6215cceb4404b334d5724e2d;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index c9b7b01f80..426862c246 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -78,18 +78,10 @@ Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner) } -void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par) -{ - owner_->text_ = par.text_; - // FIXME: change tracking (MG) - changes_ = par.pimpl_->changes_; -} - - bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const { - // FIXME: change tracking (MG) - return false; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); return changes_.isChanged(start, end); } @@ -97,16 +89,25 @@ bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const void Paragraph::Pimpl::setChange(Change const & change) { - // FIXME: change tracking (MG) - - return; - - changes_.set(change, 0, size()); - - if (change.type == Change::UNCHANGED) { // only for UNCHANGED ??? - for (pos_type i = 0; i < size(); ++i) { - if (owner_->isInset(i)) { - owner_->getInset(i)->setChange(change); + // beware of the imaginary end-of-par character! + changes_.set(change, 0, size() + 1); + + /* + * Propagate the change recursively - but not in case of DELETED! + * + * Imagine that your co-author makes changes in an existing inset. He + * sends your document to you and you come to the conclusion that the + * inset should go completely. If you erase it, LyX must not delete all + * text within the inset. Otherwise, the change tracked insertions of + * your co-author get lost and there is no way to restore them later. + * + * Conclusion: An inset's content should remain untouched if you delete it + */ + + if (change.type != Change::DELETED) { + for (pos_type pos = 0; pos < size(); ++pos) { + if (owner_->isInset(pos)) { + owner_->getInset(pos)->setChange(change); } } } @@ -115,111 +116,110 @@ void Paragraph::Pimpl::setChange(Change const & change) void Paragraph::Pimpl::setChange(pos_type pos, Change const & change) { - // FIXME: change tracking (MG) - return; + BOOST_ASSERT(pos >= 0 && pos <= size()); changes_.set(change, pos); + + // see comment in setChange(Change const &) above + + if (change.type != Change::DELETED && + pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->setChange(change); + } } Change const Paragraph::Pimpl::lookupChange(pos_type pos) const { - // FIXME: change tracking (MG) - return Change(Change::UNCHANGED); + BOOST_ASSERT(pos >= 0 && pos <= size()); return changes_.lookup(pos); } -void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end) +void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end) { - // FIXME: change tracking (MG) - return; - - // care for empty pars - - lyxerr[Debug::CHANGES] << "acceptchange" << endl; - pos_type i = start; - - for (; i < end; ++i) { - switch (lookupChange(i).type) { + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); + + for (pos_type pos = start; pos < end; ++pos) { + switch (lookupChange(pos).type) { case Change::UNCHANGED: break; case Change::INSERTED: - // FIXME: change tracking (MG) - changes_.set(Change(Change::UNCHANGED), i); + changes_.set(Change(Change::UNCHANGED), pos); break; case Change::DELETED: - // Suppress access to nonexistent - // "end-of-paragraph char": - if (i < size()) { - eraseChar(i); + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); --end; - --i; + --pos; } break; } - } - lyxerr[Debug::CHANGES] << "endacceptchange" << endl; - // FIXME: change tracking (MG) - // changes_.reset(Change::UNCHANGED); + // also accept changes in nested insets + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->acceptChanges(); + } + } } -void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end) +void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end) { - // FIXME: change tracking (MG) - return; - - // care for empty pars - - pos_type i = start; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - for (; i < end; ++i) { - switch (lookupChange(i).type) { + for (pos_type pos = start; pos < end; ++pos) { + switch (lookupChange(pos).type) { case Change::UNCHANGED: + // also reject changes inside of insets + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->rejectChanges(); + } break; case Change::INSERTED: - if (i < size()) { - eraseChar(i); + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); --end; - --i; + --pos; } break; case Change::DELETED: - // FIXME: change tracking (MG) - changes_.set(Change(Change::UNCHANGED), i); - // No real char at position size(): - if (i < size() && owner_->isInset(i)) - // FIXME: change tracking (MG) - owner_->getInset(i)->setChange(Change(Change::UNCHANGED)); + changes_.set(Change(Change::UNCHANGED), pos); + + // Do NOT reject changes within a deleted inset! + // There may be insertions of a co-author inside of it! + break; } } - // FIXME: change tracking (MG) - // changes_.reset(Change::UNCHANGED); } Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const { + BOOST_ASSERT(pos >= 0 && pos <= size()); + return owner_->getChar(pos); } void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change) { - BOOST_ASSERT(pos <= size()); + BOOST_ASSERT(pos >= 0 && pos <= size()); - // FIXME: change tracking (MG) - if (false) { - // changes_.record(change, pos); - } + // track change + changes_.insert(change, pos); // This is actually very common when parsing buffers (and // maybe inserting ascii text) @@ -233,9 +233,8 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & cha // Update the font table. FontTable search_font(pos, LyXFont()); - for (FontList::iterator it = lower_bound(fontlist.begin(), - fontlist.end(), - search_font, matchFT()); + for (FontList::iterator it + = lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT()); it != fontlist.end(); ++it) { it->pos(it->pos() + 1); @@ -246,11 +245,11 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & cha } -void Paragraph::Pimpl::insertInset(pos_type pos, - InsetBase * inset, Change const & change) +void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset, + Change const & change) { BOOST_ASSERT(inset); - BOOST_ASSERT(pos <= size()); + BOOST_ASSERT(pos >= 0 && pos <= size()); insertChar(pos, META_INSET, change); BOOST_ASSERT(owner_->text_[pos] == META_INSET); @@ -260,12 +259,36 @@ void Paragraph::Pimpl::insertInset(pos_type pos, } -void Paragraph::Pimpl::eraseChar(pos_type pos) +bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges) { - // FIXME: change tracking (MG) - // do something like changes_.erase(i); - // in one of the next patches, the two erase functions - // will be merged but I don't want to break too many things at the same time :-) + BOOST_ASSERT(pos >= 0 && pos <= size()); + + if (trackChanges) { + Change change = changes_.lookup(pos); + + // set the character to DELETED if + // a) it was previously unchanged or + // b) it was inserted by a co-author + + if (change.type == Change::UNCHANGED || + (change.type == Change::INSERTED && change.author != 0)) { + setChange(pos, Change(Change::DELETED)); + return false; + } + + if (change.type == Change::DELETED) + return false; + } + + // Don't physically access the imaginary end-of-paragraph character. + // eraseChar() can only mark it as DELETED. A physical deletion of + // end-of-par must be handled externally. + if (pos == size()) { + return false; + } + + // track change + changes_.erase(pos); // if it is an inset, delete the inset entry if (owner_->text_[pos] == Paragraph::META_INSET) { @@ -306,39 +329,16 @@ void Paragraph::Pimpl::eraseChar(pos_type pos) // Update the insetlist owner_->insetlist.decreasePosAfterPos(pos); -} - - -bool Paragraph::Pimpl::eraseChar(pos_type pos, bool /*trackChanges*/) -{ - BOOST_ASSERT(pos <= size()); - - // FIXME: change tracking (MG) - if (false) { - Change::Type changetype(changes_.lookup(pos).type); - - // only allow the actual removal if it was /new/ text - if (changetype != Change::INSERTED) { - // changes_.record(Change(Change::DELETED), pos); - if (pos < size() && owner_->isInset(pos)) - // FIXME: change tracking (MG) - owner_->getInset(pos)->setChange(Change(Change::DELETED)); - return false; - } - } - - // Don't physically access nonexistent end-of-paragraph char - if (pos < size()) { - eraseChar(pos); - return true; - } - return false; + return true; } -int Paragraph::Pimpl::erase(pos_type start, pos_type end, bool trackChanges) +int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges) { + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end >= start && end <= size() + 1); + pos_type i = start; for (pos_type count = end - start; count; --count) { if (!eraseChar(i, trackChanges))