X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=ce44bf2968af07d391383a602972e70459741935;hb=3ef684e752bb5afdbfdea51d4c3df4afe1461916;hp=51bbd4ffa42830c0ac57c1fcce589a320965a631;hpb=8b67659646c6850377cb9f44a2a0a22c0e80840c;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index 51bbd4ffa4..ce44bf2968 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -29,9 +29,8 @@ #include -using lyx::docstring; -using lyx::odocstream; -using lyx::pos_type; + +namespace lyx { using std::endl; using std::upper_bound; @@ -51,10 +50,10 @@ struct special_phrase { }; special_phrase const special_phrases[] = { - { "LyX", lyx::from_ascii("\\LyX{}"), false }, - { "TeX", lyx::from_ascii("\\TeX{}"), true }, - { "LaTeX2e", lyx::from_ascii("\\LaTeXe{}"), true }, - { "LaTeX", lyx::from_ascii("\\LaTeX{}"), true }, + { "LyX", from_ascii("\\LyX{}"), false }, + { "TeX", from_ascii("\\TeX{}"), true }, + { "LaTeX2e", from_ascii("\\LaTeXe{}"), true }, + { "LaTeX", from_ascii("\\LaTeX{}"), true }, }; size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase); @@ -71,46 +70,44 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner) Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner) - : params(p.params), owner_(owner) + : params(p.params), changes_(p.changes_), owner_(owner) { inset_owner = p.inset_owner; fontlist = p.fontlist; id_ = paragraph_id++; - - if (p.tracking()) - changes_.reset(new Changes(*p.changes_.get())); -} - - -void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par) -{ - owner_->text_ = par.text_; - if (par.pimpl_->tracking()) { - changes_.reset(new Changes(*(par.pimpl_->changes_.get()))); - } } bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const { - // FIXME: change tracking (MG) - if (!tracking()) - return false; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - return changes_->isChange(start, end); + return changes_.isChanged(start, end); } void Paragraph::Pimpl::setChange(Change const & change) { - // FIXME: change tracking (MG) - // 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)) { - // FIXME: change tracking (MG) - // 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); } } } @@ -119,113 +116,110 @@ void Paragraph::Pimpl::setChange(Change const & change) void Paragraph::Pimpl::setChange(pos_type pos, Change const & change) { - if (!tracking()) - return; + BOOST_ASSERT(pos >= 0 && pos <= size()); - changes_->set(change, pos); + 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 { - if (!tracking()) - return Change(Change::UNCHANGED); + BOOST_ASSERT(pos >= 0 && pos <= size()); - return changes_->lookup(pos); + return changes_.lookup(pos); } -void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end) +void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end) { - if (!tracking()) - return; - - if (!size()) { - changes_.reset(new Changes(Change::UNCHANGED)); - return; - } - - 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: - changes_->set(Change::UNCHANGED, i); + changes_.set(Change(Change::UNCHANGED), pos); break; case Change::DELETED: - // Suppress access to nonexistent - // "end-of-paragraph char": - if (i < size()) { - eraseIntern(i); - changes_->erase(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; - 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) { - if (!tracking()) - return; - - if (!size()) { - changes_.reset(new Changes(Change::UNCHANGED)); - return; - } - - 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()) { - eraseIntern(i); - changes_->erase(i); + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); --end; - --i; + --pos; } break; case Change::DELETED: - changes_->set(Change::UNCHANGED, i); - // No real char at position size(): - if (i < size() && owner_->isInset(i)) - owner_->getInset(i)->markErased(false); + 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; } } - 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()); - if (tracking()) { - changes_->record(change, pos); - } + // track change + changes_.insert(change, pos); // This is actually very common when parsing buffers (and // maybe inserting ascii text) @@ -239,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); @@ -252,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); @@ -266,8 +259,37 @@ void Paragraph::Pimpl::insertInset(pos_type pos, } -void Paragraph::Pimpl::eraseIntern(pos_type pos) +bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges) { + 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 nonexistent end-of-paragraph char + if (pos == size()) { + // FIXME: change tracking (MG) + // how do we handle end-of-pars previously marked inserted? + return false; + } + + // track change + changes_.erase(pos); + // if it is an inset, delete the inset entry if (owner_->text_[pos] == Paragraph::META_INSET) { owner_->insetlist.erase(pos); @@ -300,47 +322,26 @@ void Paragraph::Pimpl::eraseIntern(pos_type pos) } } - // Update all other entries. + // Update all other entries FontList::iterator fend = fontlist.end(); for (; it != fend; ++it) it->pos(it->pos() - 1); - // Update the insetlist. + // Update the insetlist owner_->insetlist.decreasePosAfterPos(pos); -} - -bool Paragraph::Pimpl::erase(pos_type pos) -{ - BOOST_ASSERT(pos <= size()); - - if (tracking()) { - 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)) - owner_->getInset(pos)->markErased(true); - return false; - } - } - - // Don't physically access nonexistent end-of-paragraph char - if (pos < size()) { - eraseIntern(pos); - return true; - } - - return false; + return true; } -int Paragraph::Pimpl::erase(pos_type start, pos_type end) +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 (!erase(i)) + if (!eraseChar(i, trackChanges)) ++i; } return end - i; @@ -541,9 +542,18 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, column += 15; break; - case '±': case '²': case '³': - case '×': case '÷': case '¹': - case '¬': case 'µ': + // The following characters could be written literally in latin1, but they + // would be wrongly converted on systems where char is signed, so we give + // the code points. + // This also makes us independant from the encoding of this source file. + case 0xb1: // ± PLUS-MINUS SIGN + case 0xb2: // ² SUPERSCRIPT TWO + case 0xb3: // ³ SUPERSCRIPT THREE + case 0xd7: // × MULTIPLICATION SIGN + case 0xf7: // ÷ DIVISION SIGN + case 0xb9: // ¹ SUPERSCRIPT ONE + case 0xac: // ¬ NOT SIGN + case 0xb5: // µ MICRO SIGN if ((bparams.inputenc == "latin1" || bparams.inputenc == "latin9") || (bparams.inputenc == "auto" && @@ -551,19 +561,19 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, == "latin1" || font.language()->encoding()->latexName() == "latin9"))) { - os << "\\ensuremath{" - << c - << '}'; + os << "\\ensuremath{"; + os.put(c); + os << '}'; column += 13; } else { - os << c; + os.put(c); } break; case '|': case '<': case '>': // In T1 encoding, these characters exist if (lyxrc.fontenc == "T1") { - os << c; + os.put(c); //... but we should avoid ligatures if ((c == '>' || c == '<') && i <= size() - 2 @@ -580,7 +590,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, } // Typewriter font also has them if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - os << c; + os.put(c); break; } // Otherwise, we use what LaTeX @@ -617,19 +627,20 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, column += 9; break; - case '£': + case 0xa3: // £ POUND SIGN if (bparams.inputenc == "default") { os << "\\pounds{}"; column += 8; } else { - os << c; + os.put(c); } break; case '$': case '&': case '%': case '#': case '{': case '}': case '_': - os << '\\' << c; + os << '\\'; + os.put(c); column += 1; break; @@ -645,7 +656,9 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, case '*': case '[': // avoid being mistaken for optional arguments - os << '{' << c << '}'; + os << '{'; + os.put(c); + os << '}'; column += 2; break; @@ -662,7 +675,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, // I assume this is hack treating typewriter as verbatim if (font.family() == LyXFont::TYPEWRITER_FAMILY) { if (c != '\0') { - os << c; + os.put(c); } break; } @@ -687,7 +700,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, } if (pnr == phrases_nr && c != '\0') { - os << c; + os.put(c); } break; } @@ -775,3 +788,6 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, } } } + + +} // namespace lyx