X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=da326879c5cc2c15f1fddf8e00f71e23b5337bc0;hb=ae348f8af96100a154b3792d27732d621d44ec89;hp=9f898a515a931fb331d801883bd84d44c347a293;hpb=d9d8fa107b7f4ff0fabda989e3b6588831db4007;p=lyx.git diff --git a/src/text.C b/src/text.C index 9f898a515a..da326879c5 100644 --- a/src/text.C +++ b/src/text.C @@ -24,6 +24,7 @@ #include "bufferparams.h" #include "BufferView.h" #include "cursor.h" +#include "pariterator.h" #include "coordcache.h" #include "CutAndPaste.h" #include "debug.h" @@ -74,6 +75,7 @@ #include +using lyx::char_type; using lyx::pit_type; using lyx::pos_type; using lyx::word_location; @@ -133,7 +135,7 @@ int numberOfLabelHfills(Paragraph const & par, Row const & row) int numberOfHfills(Paragraph const & par, Row const & row) { - pos_type const last = row.endpos() - 1; + pos_type const last = row.endpos(); pos_type first = row.pos(); // hfill *DO* count at the beginning of paragraphs! @@ -195,13 +197,13 @@ void readParToken(Buffer const & buf, Paragraph & par, LyXLex & lex, } else if (token == "\\end_layout") { lyxerr << BOOST_CURRENT_FUNCTION - << ": Solitary \\end_layout in line " - << lex.getLineNo() << "\n" + << ": Solitary \\end_layout in line " + << lex.getLineNo() << "\n" << "Missing \\begin_layout?.\n"; } else if (token == "\\end_inset") { lyxerr << BOOST_CURRENT_FUNCTION - << ": Solitary \\end_inset in line " - << lex.getLineNo() << "\n" + << ": Solitary \\end_inset in line " + << lex.getLineNo() << "\n" << "Missing \\begin_inset?.\n"; } else if (token == "\\begin_inset") { InsetBase * inset = readInset(lex, buf); @@ -315,23 +317,39 @@ void readParToken(Buffer const & buf, Paragraph & par, LyXLex & lex, } else if (token == "\\change_unchanged") { // Hack ! Needed for empty paragraphs :/ // FIXME: is it still ?? + /* if (!par.size()) par.cleanChanges(); + */ change = Change(Change::UNCHANGED); } else if (token == "\\change_inserted") { lex.eatLine(); std::istringstream is(lex.getString()); - int aid; + unsigned int aid; lyx::time_type ct; is >> aid >> ct; - change = Change(Change::INSERTED, bp.author_map[aid], ct); + if (aid >= bp.author_map.size()) { + buf.error(ErrorItem(_("Change tracking error"), + bformat(_("Unknown author index for insertion: %1$d\n"), aid), + par.id(), 0, par.size())); + + change = Change(Change::UNCHANGED); + } else + change = Change(Change::INSERTED, bp.author_map[aid], ct); } else if (token == "\\change_deleted") { lex.eatLine(); std::istringstream is(lex.getString()); - int aid; + unsigned int aid; lyx::time_type ct; is >> aid >> ct; - change = Change(Change::DELETED, bp.author_map[aid], ct); + if (aid >= bp.author_map.size()) { + buf.error(ErrorItem(_("Change tracking error"), + bformat(_("Unknown author index for deletion: %1$d\n"), aid), + par.id(), 0, par.size())); + + change = Change(Change::UNCHANGED); + } else + change = Change(Change::DELETED, bp.author_map[aid], ct); } else { lex.eatLine(); buf.error(ErrorItem(_("Unknown token"), @@ -375,6 +393,9 @@ void readParagraph(Buffer const & buf, Paragraph & par, LyXLex & lex) break; } } + // Final change goes to paragraph break: + par.setChange(par.size(), change); + // Initialize begin_of_body_ on load; redoParagraph maintains par.setBeginOfBody(); } @@ -418,20 +439,20 @@ int LyXText::singleWidth(Paragraph const & par, pos_type pos) const int LyXText::singleWidth(Paragraph const & par, - pos_type pos, char c, LyXFont const & font) const + pos_type pos, char_type c, LyXFont const & font) const { // The most common case is handled first (Asger) - if (IsPrintable(c)) { + if (isPrintable(c)) { Language const * language = font.language(); - if (language->RightToLeft()) { + if (language->rightToLeft()) { if ((lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 || lyxrc.font_norm_type == LyXRC::ISO_10646_1) && language->lang() == "arabic") { - if (Encodings::IsComposeChar_arabic(c)) + if (Encodings::isComposeChar_arabic(c)) return 0; c = par.transformChar(c, pos); } else if (language->lang() == "hebrew" && - Encodings::IsComposeChar_hebrew(c)) + Encodings::isComposeChar_hebrew(c)) return 0; } return font_metrics::width(c, font); @@ -460,8 +481,8 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const BOOST_ASSERT(pos >= 0); BOOST_ASSERT(pos <= par.size()); //lyxerr << "LyXText::leftMargin: pit: " << pit << " pos: " << pos << endl; - LyXTextClass const & tclass = - bv()->buffer()->params().getLyXTextClass(); + BufferParams const & params = bv()->buffer()->params(); + LyXTextClass const & tclass = params.getLyXTextClass(); LyXLayout_ptr const & layout = par.layout(); string parindent = layout->parindent; @@ -471,11 +492,11 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const if (isMainText()) l_margin += changebarMargin(); - l_margin += font_metrics::signedWidth(tclass.leftmargin(), tclass.defaultfont()); + l_margin += font_metrics::signedWidth(tclass.leftmargin(), params.getFont()); if (par.getDepth() != 0) { - // find the next level paragraph - pit_type newpar = outerHook(pit, pars_); + // find the next level paragraph + pit_type newpar = outerHook(pit, pars_); if (newpar != pit_type(pars_.size())) { if (pars_[newpar].layout()->isEnvironment()) { l_margin = leftMargin(newpar); @@ -489,12 +510,19 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const } } + // This happens after sections in standard classes. The 1.3.x + // code compared depths too, but it does not seem necessary + // (JMarc) + if (par.layout() == tclass.defaultLayout() + && pit > 0 && pars_[pit - 1].layout()->nextnoindent) + parindent.erase(); + LyXFont const labelfont = getLabelFont(par); switch (layout->margintype) { case MARGIN_DYNAMIC: if (!layout->leftmargin.empty()) l_margin += font_metrics::signedWidth(layout->leftmargin, - tclass.defaultfont()); + params.getFont()); if (!par.getLabelstring().empty()) { l_margin += font_metrics::signedWidth(layout->labelindent, labelfont); @@ -517,7 +545,7 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const break; case MARGIN_STATIC: - l_margin += font_metrics::signedWidth(layout->leftmargin, tclass.defaultfont()) * 4 + l_margin += font_metrics::signedWidth(layout->leftmargin, params.getFont()) * 4 / (par.getDepth() + 4); break; @@ -564,7 +592,7 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const if (rit->fill() < minfill) minfill = rit->fill(); l_margin += font_metrics::signedWidth(layout->leftmargin, - tclass.defaultfont()); + params.getFont()); l_margin += minfill; #endif // also wrong, but much shorter. @@ -589,8 +617,8 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const || layout->labeltype == LABEL_TOP_ENVIRONMENT || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT || (layout->labeltype == LABEL_STATIC - && layout->latextype == LATEX_ENVIRONMENT - && !isFirstInSequence(pit, pars_))) + && layout->latextype == LATEX_ENVIRONMENT + && !isFirstInSequence(pit, pars_))) && align == LYX_ALIGN_BLOCK && !par.params().noindent() // in some insets, paragraphs are never indented @@ -600,10 +628,10 @@ int LyXText::leftMargin(pit_type const pit, pos_type const pos) const && par.isInset(pos) && par.getInset(pos)->display()) && (par.layout() != tclass.defaultLayout() - || bv()->buffer()->params().paragraph_separation == - BufferParams::PARSEP_INDENT)) + || bv()->buffer()->params().paragraph_separation == + BufferParams::PARSEP_INDENT)) { - l_margin += font_metrics::signedWidth(parindent, tclass.defaultfont()); + l_margin += font_metrics::signedWidth(parindent, params.getFont()); } return l_margin; @@ -616,13 +644,14 @@ int LyXText::rightMargin(Paragraph const & par) const if (bv()->text() != this) return 0; - LyXTextClass const & tclass = bv()->buffer()->params().getLyXTextClass(); + BufferParams const & params = bv()->buffer()->params(); + LyXTextClass const & tclass = params.getLyXTextClass(); int const r_margin = ::rightMargin() + font_metrics::signedWidth(tclass.rightmargin(), - tclass.defaultfont()) + params.getFont()) + font_metrics::signedWidth(par.layout()->rightmargin, - tclass.defaultfont()) + params.getFont()) * 4 / (par.getDepth() + 4); return r_margin; @@ -697,7 +726,7 @@ void LyXText::rowBreakPoint(pit_type const pit, Row & row) const pos_type point = end; pos_type i = pos; for ( ; i < end; ++i, ++fi) { - char const c = par.getChar(i); + char_type const c = par.getChar(i); int thiswidth = singleWidth(par, i, c, *fi); // add the auto-hfill from label end to the body @@ -790,7 +819,7 @@ void LyXText::setRowWidth(pit_type const pit, Row & row) const w -= singleWidth(par, i - 1); w = max(w, labelEnd(pit)); } - char const c = par.getChar(i); + char_type const c = par.getChar(i); w += singleWidth(par, i, c, *fi); } } @@ -908,7 +937,7 @@ void LyXText::setHeightOfRow(pit_type const pit, Row & row) && pit != 0 && ((layout->isParagraph() && par.getDepth() == 0) || (pars_[pit - 1].layout()->isParagraph() - && pars_[pit - 1].getDepth() == 0))) + && pars_[pit - 1].getDepth() == 0))) { maxasc += bufparams.getDefSkip().inPixels(*bv()); } @@ -921,8 +950,8 @@ void LyXText::setHeightOfRow(pit_type const pit, Row & row) if (layout->counter == "chapter" && !par.params().labelString().empty()) { labeladdon = int(font_metrics::maxHeight(labelfont) - * layout->spacing.getValue() - * spacing(par)); + * layout->spacing.getValue() + * spacing(par)); } // special code for the top label @@ -1002,7 +1031,8 @@ void LyXText::setHeightOfRow(pit_type const pit, Row & row) if (bv_owner->text() == this) { if (pit == 0 && row.pos() == 0) maxasc += 20; - if (pit + 1 == pars_.size() && row.endpos() == par.size()) + if (pit + 1 == pit_type(pars_.size()) && + row.endpos() == par.size()) maxdesc += 20; } @@ -1018,14 +1048,10 @@ namespace { void LyXText::breakParagraph(LCursor & cur, bool keep_layout) { BOOST_ASSERT(this == cur.text()); - // allow only if at start or end, or all previous is new text + Paragraph & cpar = cur.paragraph(); pit_type cpit = cur.pit(); - if (cur.pos() != 0 && cur.pos() != cur.lastpos() - && cpar.isChangeEdited(0, cur.pos())) - return; - LyXTextClass const & tclass = cur.buffer().params().getLyXTextClass(); LyXLayout_ptr const & layout = cpar.layout(); @@ -1078,7 +1104,18 @@ void LyXText::breakParagraph(LCursor & cur, bool keep_layout) while (!pars_[next_par].empty() && pars_[next_par].isNewline(0)) pars_[next_par].erase(0); - updateCounters(cur.buffer()); + ParIterator current_it(cur); + ParIterator last_it(cur); + ++last_it; + ++last_it; + + updateLabels(cur.buffer(), current_it, last_it); + + // Mark "carriage return" as inserted if change tracking: + if (cur.buffer().params().tracking_changes) { + cur.paragraph().setChange(cur.paragraph().size(), + Change::INSERTED); + } // This check is necessary. Otherwise the new empty paragraph will // be deleted automatically. And it is more friendly for the user! @@ -1091,7 +1128,7 @@ void LyXText::breakParagraph(LCursor & cur, bool keep_layout) // insert a character, moves all the following breaks in the // same Paragraph one to the right and make a rebreak -void LyXText::insertChar(LCursor & cur, char c) +void LyXText::insertChar(LCursor & cur, char_type c) { BOOST_ASSERT(this == cur.text()); BOOST_ASSERT(c != Paragraph::META_INSET); @@ -1111,7 +1148,7 @@ void LyXText::insertChar(LCursor & cur, char c) static string const number_seperators = ".,:"; if (current_font.number() == LyXFont::ON) { - if (!IsDigit(c) && !contains(number_operators, c) && + if (!isDigit(c) && !contains(number_operators, c) && !(contains(number_seperators, c) && cur.pos() != 0 && cur.pos() != cur.lastpos() && @@ -1119,12 +1156,12 @@ void LyXText::insertChar(LCursor & cur, char c) getFont(par, cur.pos() - 1).number() == LyXFont::ON) ) number(cur); // Set current_font.number to OFF - } else if (IsDigit(c) && + } else if (isDigit(c) && real_current_font.isVisibleRightToLeft()) { number(cur); // Set current_font.number to ON if (cur.pos() != 0) { - char const c = par.getChar(cur.pos() - 1); + char_type const c = par.getChar(cur.pos() - 1); if (contains(number_unary_operators, c) && (cur.pos() == 1 || par.isSeparator(cur.pos() - 2) @@ -1146,19 +1183,9 @@ void LyXText::insertChar(LCursor & cur, char c) // difference are the special checks when calculating the row.fill // (blank does not count at the end of a row) and the check here - // The bug is triggered when we type in a description environment: - // The current_font is not changed when we go from label to main text - // and it should (along with realtmpfont) when we type the space. - // CHECK There is a bug here! (Asger) - - // store the current font. This is because of the use of cursor - // movements. The moving cursor would refresh the current font - LyXFont realtmpfont = real_current_font; - LyXFont rawtmpfont = current_font; - // When the free-spacing option is set for the current layout, // disable the double-space checking - if (!freeSpacing && IsLineSeparatorChar(c)) { + if (!freeSpacing && isLineSeparatorChar(c)) { if (cur.pos() == 0) { static bool sent_space_message = false; if (!sent_space_message) { @@ -1182,12 +1209,8 @@ void LyXText::insertChar(LCursor & cur, char c) } } - par.insertChar(cur.pos(), c, rawtmpfont); - - current_font = rawtmpfont; - real_current_font = realtmpfont; - //setCursor(cur, cur.pit(), cur.pos() + 1, false, cur.boundary()); - setCursor(cur, cur.pit(), cur.pos() + 1, false, true); + par.insertChar(cur.pos(), c, current_font); + setCursor(cur, cur.pit(), cur.pos() + 1, false, cur.boundary()); charInserted(); } @@ -1332,13 +1355,12 @@ bool LyXText::cursorRightOneWord(LCursor & cur) ++old.pit(); old.pos() = 0; } else { - // Skip through initial nonword stuff. - // Treat floats and insets as words. - while (old.pos() != old.lastpos() && !old.paragraph().isLetter(old.pos())) - ++old.pos(); // Advance through word. while (old.pos() != old.lastpos() && old.paragraph().isLetter(old.pos())) ++old.pos(); + // Skip through trailing nonword stuff. + while (old.pos() != old.lastpos() && !old.paragraph().isLetter(old.pos())) + ++old.pos(); } return setCursor(cur, old.pit(), old.pos()); } @@ -1355,7 +1377,6 @@ bool LyXText::cursorLeftOneWord(LCursor & cur) old.pos() = old.lastpos(); } else { // Skip through initial nonword stuff. - // Treat floats and insets as words. while (old.pos() != 0 && !old.paragraph().isLetter(old.pos() - 1)) --old.pos(); // Advance through word. @@ -1400,18 +1421,34 @@ void LyXText::acceptChange(LCursor & cur) if (!cur.selection() && cur.lastpos() != 0) return; - CursorSlice const & startc = cur.selBegin(); - CursorSlice const & endc = cur.selEnd(); - if (startc.pit() == endc.pit()) { - recordUndoSelection(cur, Undo::INSERT); - pars_[startc.pit()].acceptChange(startc.pos(), endc.pos()); - finishUndo(); - cur.clearSelection(); - setCursorIntern(cur, startc.pit(), 0); + recordUndoSelection(cur, Undo::INSERT); + + DocIterator it = cur.selectionBegin(); + DocIterator et = cur.selectionEnd(); + pit_type pit = it.pit(); + Change::Type const type = pars_[pit].lookupChange(it.pos()).type; + for (; pit <= et.pit(); ++pit) { + pos_type left = ( pit == it.pit() ? it.pos() : 0 ); + pos_type right = + ( pit == et.pit() ? et.pos() : pars_[pit].size() + 1 ); + pars_[pit].acceptChange(left, right); } -#ifdef WITH_WARNINGS -#warning handle multi par selection -#endif + if (type == Change::DELETED) { + ParagraphList & plist = paragraphs(); + if (it.pit() + 1 < et.pit()) + pars_.erase(boost::next(plist.begin(), it.pit() + 1), + boost::next(plist.begin(), et.pit())); + + // Paragraph merge if appropriate: + if (pars_[it.pit()].lookupChange(pars_[it.pit()].size()) + == Change::DELETED) { + setCursorIntern(cur, it.pit() + 1, 0); + backspacePos0(cur); + } + } + finishUndo(); + cur.clearSelection(); + setCursorIntern(cur, it.pit(), 0); } @@ -1421,18 +1458,33 @@ void LyXText::rejectChange(LCursor & cur) if (!cur.selection() && cur.lastpos() != 0) return; - CursorSlice const & startc = cur.selBegin(); - CursorSlice const & endc = cur.selEnd(); - if (startc.pit() == endc.pit()) { - recordUndoSelection(cur, Undo::INSERT); - pars_[startc.pit()].rejectChange(startc.pos(), endc.pos()); - finishUndo(); - cur.clearSelection(); - setCursorIntern(cur, startc.pit(), 0); + recordUndoSelection(cur, Undo::INSERT); + + DocIterator it = cur.selectionBegin(); + DocIterator et = cur.selectionEnd(); + pit_type pit = it.pit(); + Change::Type const type = pars_[pit].lookupChange(it.pos()).type; + for (; pit <= et.pit(); ++pit) { + pos_type left = ( pit == it.pit() ? it.pos() : 0 ); + pos_type right = + ( pit == et.pit() ? et.pos() : pars_[pit].size() + 1 ); + pars_[pit].rejectChange(left, right); } -#ifdef WITH_WARNINGS -#warning handle multi par selection -#endif + if (type == Change::INSERTED) { + ParagraphList & plist = paragraphs(); + if (it.pit() + 1 < et.pit()) + pars_.erase(boost::next(plist.begin(), it.pit() + 1), + boost::next(plist.begin(), et.pit())); + // Paragraph merge if appropriate: + if (pars_[it.pit()].lookupChange(pars_[it.pit()].size()) + == Change::INSERTED) { + setCursorIntern(cur, it.pit() + 1, 0); + backspacePos0(cur); + } + } + finishUndo(); + cur.clearSelection(); + setCursorIntern(cur, it.pit(), 0); } @@ -1501,7 +1553,7 @@ void LyXText::changeCase(LCursor & cur, LyXText::TextCase action) } else { from = cur.top(); getWord(from, to, lyx::PARTIAL_WORD); - setCursor(cur, to.pit(), to.pos() + 1); + cursorRightOneWord(cur); } recordUndoSelection(cur); @@ -1516,7 +1568,7 @@ void LyXText::changeCase(LCursor & cur, LyXText::TextCase action) pos = 0; continue; } - unsigned char c = pars_[pit].getChar(pos); + char_type c = pars_[pit].getChar(pos); if (c != Paragraph::META_INSET) { switch (action) { case text_lowercase: @@ -1540,106 +1592,137 @@ void LyXText::changeCase(LCursor & cur, LyXText::TextCase action) } -void LyXText::Delete(LCursor & cur) +bool LyXText::erase(LCursor & cur) { BOOST_ASSERT(this == cur.text()); + bool needsUpdate = false; if (cur.pos() != cur.lastpos()) { recordUndo(cur, Undo::DELETE, cur.pit()); setCursorIntern(cur, cur.pit(), cur.pos() + 1, false, cur.boundary()); - backspace(cur); + needsUpdate = backspace(cur); + if (cur.paragraph().lookupChange(cur.pos()) == Change::DELETED) + cur.posRight(); } else if (cur.pit() != cur.lastpit()) { LCursor scur = cur; - setCursorIntern(cur, cur.pit()+1, 0, false, false); + setCursorIntern(cur, cur.pit() + 1, 0, false, false); if (pars_[cur.pit()].layout() == pars_[scur.pit()].layout()) { recordUndo(scur, Undo::DELETE, scur.pit()); - backspace(cur); + needsUpdate = backspace(cur); + if (cur.buffer().params().tracking_changes) { + // move forward after the paragraph break is DELETED + Paragraph & par = cur.paragraph(); + if (par.lookupChange(par.size()) == Change::DELETED) + setCursorIntern(cur, cur.pit() + 1, 0); + } } else { setCursorIntern(scur, scur.pit(), scur.pos(), false, scur.boundary()); } } + return needsUpdate; } -void LyXText::backspace(LCursor & cur) +bool LyXText::backspacePos0(LCursor & cur) { BOOST_ASSERT(this == cur.text()); - if (cur.pos() == 0) { - // The cursor is at the beginning of a paragraph, so - // the the backspace will collapse two paragraphs into - // one. + bool needsUpdate = false; - // but it's not allowed unless it's new - Paragraph & par = cur.paragraph(); - if (par.isChangeEdited(0, par.size())) - return; + Paragraph & par = cur.paragraph(); + // is it an empty paragraph? + pos_type lastpos = cur.lastpos(); + if (lastpos == 0 || (lastpos == 1 && par.isSeparator(0))) { + // This is an empty paragraph and we delete it just + // by moving the cursor one step + // left and let the DeleteEmptyParagraphMechanism + // handle the actual deletion of the paragraph. - // we may paste some paragraphs - - // is it an empty paragraph? - pos_type lastpos = cur.lastpos(); - if (lastpos == 0 || (lastpos == 1 && par.isSeparator(0))) { - // This is an empty paragraph and we delete it just - // by moving the cursor one step - // left and let the DeleteEmptyParagraphMechanism - // handle the actual deletion of the paragraph. - - if (cur.pit() != 0) { - // For KeepEmpty layouts we need to get - // rid of the keepEmpty setting first. - // And the only way to do this is to - // reset the layout to something - // else: f.ex. the default layout. - if (par.allowEmpty()) { - Buffer & buf = cur.buffer(); - BufferParams const & bparams = buf.params(); - par.layout(bparams.getLyXTextClass().defaultLayout()); - } - - cursorLeft(cur); - return; + if (cur.pit() != 0) { + // For KeepEmpty layouts we need to get + // rid of the keepEmpty setting first. + // And the only way to do this is to + // reset the layout to something + // else: f.ex. the default layout. + if (par.allowEmpty()) { + Buffer & buf = cur.buffer(); + BufferParams const & bparams = buf.params(); + par.layout(bparams.getLyXTextClass().defaultLayout()); } + + cursorLeft(cur); + return true; } + } - if (cur.pit() != 0) - recordUndo(cur, Undo::DELETE, cur.pit() - 1); + if (cur.pit() != 0) + recordUndo(cur, Undo::DELETE, cur.pit() - 1); + + pit_type tmppit = cur.pit(); + // We used to do cursorLeftIntern() here, but it is + // not a good idea since it triggers the auto-delete + // mechanism. So we do a cursorLeftIntern()-lite, + // without the dreaded mechanism. (JMarc) + if (cur.pit() != 0) { + // steps into the above paragraph. + setCursorIntern(cur, cur.pit() - 1, + pars_[cur.pit() - 1].size(), + false); + } - pit_type tmppit = cur.pit(); - // We used to do cursorLeftIntern() here, but it is - // not a good idea since it triggers the auto-delete - // mechanism. So we do a cursorLeftIntern()-lite, - // without the dreaded mechanism. (JMarc) - if (cur.pit() != 0) { - // steps into the above paragraph. - setCursorIntern(cur, cur.pit() - 1, - pars_[cur.pit() - 1].size(), - false); - } + // Pasting is not allowed, if the paragraphs have different + // layout. I think it is a real bug of all other + // word processors to allow it. It confuses the user. + // Correction: Pasting is always allowed with standard-layout + // Correction (Jug 20050717): Remove check about alignment! + Buffer & buf = cur.buffer(); + BufferParams const & bufparams = buf.params(); + LyXTextClass const & tclass = bufparams.getLyXTextClass(); + pit_type const cpit = cur.pit(); - // Pasting is not allowed, if the paragraphs have different - // layout. I think it is a real bug of all other - // word processors to allow it. It confuses the user. - // Correction: Pasting is always allowed with standard-layout - // Correction (Jug 20050717): Remove check about alignment! - Buffer & buf = cur.buffer(); - BufferParams const & bufparams = buf.params(); - LyXTextClass const & tclass = bufparams.getLyXTextClass(); - pit_type const cpit = cur.pit(); - - if (cpit != tmppit - && (pars_[cpit].layout() == pars_[tmppit].layout() - || pars_[tmppit].layout() == tclass.defaultLayout())) - { - mergeParagraph(bufparams, pars_, cpit); + if (cpit != tmppit + && (pars_[cpit].layout() == pars_[tmppit].layout() + || pars_[tmppit].layout() == tclass.defaultLayout())) + { + mergeParagraph(bufparams, pars_, cpit); + needsUpdate = true; - if (cur.pos() != 0 && pars_[cpit].isSeparator(cur.pos() - 1)) + if (cur.pos() != 0 && pars_[cpit].isSeparator(cur.pos() - 1)) --cur.pos(); - // the counters may have changed - updateCounters(cur.buffer()); - setCursor(cur, cur.pit(), cur.pos(), false); + // the counters may have changed + ParIterator par_it(cur); + updateLabels(cur.buffer(), par_it); + + setCursor(cur, cur.pit(), cur.pos(), false); + } + return needsUpdate; +} + + +bool LyXText::backspace(LCursor & cur) +{ + BOOST_ASSERT(this == cur.text()); + bool needsUpdate = false; + if (cur.pos() == 0) { + // The cursor is at the beginning of a paragraph, so + // the the backspace will collapse two paragraphs into + // one. + + if (cur.pit() != 0 && cur.buffer().params().tracking_changes) { + // Previous paragraph, mark "carriage return" as + // deleted: + Paragraph & par = pars_[cur.pit() - 1]; + // Take care of a just inserted para break: + if (par.lookupChange(par.size()) != Change::INSERTED) { + par.setChange(par.size(), Change::DELETED); + setCursorIntern(cur, cur.pit() - 1, par.size()); + return true; + } } + + needsUpdate = backspacePos0(cur); + } else { // this is the code for a normal backspace, not pasting // any paragraphs @@ -1657,6 +1740,8 @@ void LyXText::backspace(LCursor & cur) setCurrentFont(cur); setCursor(cur, cur.pit(), cur.pos(), false, cur.boundary()); + + return needsUpdate; } @@ -1678,7 +1763,7 @@ bool LyXText::redoParagraph(pit_type const pit) // Insist on it being in pos 0 && par.getChar(0) == Paragraph::META_INSET) { InsetBase * inset = par.insetlist.begin()->inset; - if (inset->lyxCode() == InsetBase::BIBITEM_CODE) + if (inset->lyxCode() == InsetBase::BIBITEM_CODE) hasbibitem = true; } if (!hasbibitem) { @@ -1690,12 +1775,18 @@ bool LyXText::redoParagraph(pit_type const pit) } // redo insets + // FIXME: We should always use getFont(), see documentation of + // noFontChange() in insetbase.h. + LyXFont const bufferfont = bv()->buffer()->params().getFont(); InsetList::iterator ii = par.insetlist.begin(); InsetList::iterator iend = par.insetlist.end(); for (; ii != iend; ++ii) { Dimension dim; int const w = maxwidth_ - leftMargin(pit, ii->pos) - rightMargin(par); - MetricsInfo mi(bv(), getFont(par, ii->pos), w); + LyXFont const & font = ii->inset->noFontChange() ? + bufferfont : + getFont(par, ii->pos); + MetricsInfo mi(bv(), font, w); ii->inset->metrics(mi, dim); } @@ -1716,6 +1807,20 @@ bool LyXText::redoParagraph(pit_type const pit) z = row.endpos(); } while (z < par.size()); + // Make sure that if a par ends in newline, there is one more row + // under it + // FIXME this is a dirty trick. Now the _same_ position in the + // paragraph occurs in _two_ different rows, and has two different + // display positions, leading to weird behaviour when moving up/down. + if (z > 0 && par.isNewline(z - 1)) { + Row row(z - 1); + row.endpos(z - 1); + setRowWidth(pit, row); + setHeightOfRow(pit, row); + par.rows().push_back(row); + dim.des += row.height(); + } + dim.asc += par.rows()[0].ascent(); dim.des -= par.rows()[0].ascent(); @@ -1775,12 +1880,8 @@ void LyXText::drawSelection(PainterInfo & pi, int x , int) const lyxerr << "draw selection at " << x << endl; - // is there a better way of getting these two iterators? - DocIterator beg = cur; - DocIterator end = cur; - - beg.top() = cur.selBegin(); - end.top() = cur.selEnd(); + DocIterator beg = cur.selectionBegin(); + DocIterator end = cur.selectionEnd(); // the selection doesn't touch the visible screen if (bv_funcs::status(pi.base.bv, beg) == bv_funcs::CUR_BELOW @@ -1844,16 +1945,12 @@ void LyXText::drawSelection(PainterInfo & pi, int x, int) const return; lyxerr[Debug::DEBUG] - << BOOST_CURRENT_FUNCTION - << "draw selection at " << x - << endl; - - // is there a better way of getting these two iterators? - DocIterator beg = cur; - DocIterator end = cur; + << BOOST_CURRENT_FUNCTION + << "draw selection at " << x + << endl; - beg.top() = cur.selBegin(); - end.top() = cur.selEnd(); + DocIterator beg = cur.selectionBegin(); + DocIterator end = cur.selectionEnd(); // the selection doesn't touch the visible screen if (bv_funcs::status(pi.base.bv, beg) == bv_funcs::CUR_BELOW @@ -2124,14 +2221,22 @@ int LyXText::cursorX(CursorSlice const & sl, bool boundary) const else if (par.isSeparator(pos) && pos >= body_pos) x += m.separator; } - + // see correction above if (boundary_correction) - if (getFont(par, ppos).isRightToLeft()) + if (getFont(par, ppos).isVisibleRightToLeft()) x -= singleWidth(par, ppos); else x += singleWidth(par, ppos); + // Make sure inside an inset we always count from the left + // edge (bidi!) -- MV + if (sl.pos() < par.size()) { + font = getFont(par, sl.pos()); + if (!boundary && font.isVisibleRightToLeft() + && par.isInset(sl.pos())) + x -= par.getInset(sl.pos())->width(); + } return int(x); } @@ -2140,6 +2245,9 @@ int LyXText::cursorY(CursorSlice const & sl, bool boundary) const { //lyxerr << "LyXText::cursorY: boundary: " << boundary << std::endl; Paragraph const & par = getPar(sl.pit()); + if (par.rows().empty()) + return 0; + int h = 0; h -= pars_[0].rows()[0].ascent(); for (pit_type pit = 0; pit < sl.pit(); ++pit) @@ -2164,11 +2272,13 @@ string LyXText::currentState(LCursor & cur) std::ostringstream os; bool const show_change = buf.params().tracking_changes - && cur.pos() != cur.lastpos() && par.lookupChange(cur.pos()) != Change::UNCHANGED; + if (buf.params().tracking_changes) + os << "[C] "; + if (show_change) { - Change change = par.lookupChangeFull(cur.pos()); + Change change = par.lookupChange(cur.pos()); Author const & a = buf.params().authors().get(change.author); os << _("Change: ") << a.name(); if (!a.email().empty()) @@ -2180,8 +2290,9 @@ string LyXText::currentState(LCursor & cur) // I think we should only show changes from the default // font. (Asger) + // No, from the document font (MV) LyXFont font = real_current_font; - font.reduce(buf.params().getLyXTextClass().defaultfont()); + font.reduce(buf.params().getFont()); // avoid _(...) re-entrance problem string const s = font.stateText(&buf.params()); @@ -2245,8 +2356,25 @@ string LyXText::getPossibleLabel(LCursor & cur) const } } - string text = layout->latexname().substr(0, 3); - if (layout->latexname() == "theorem") + string name = layout->latexname(); + + // for captions, we want the abbreviation of the float type + if (layout->labeltype == LABEL_SENSITIVE) { + // Search for the first float or wrap inset in the iterator + size_t i = cur.depth(); + while (i > 0) { + --i; + InsetBase * const in = &cur[i].inset(); + if (in->lyxCode() == InsetBase::FLOAT_CODE + || in->lyxCode() == InsetBase::WRAP_CODE) { + name = in->getInsetName(); + break; + } + } + } + + string text = name.substr(0, 3); + if (name == "theorem") text = "thm"; // Create a correct prefix for prettyref text += ':'; @@ -2306,16 +2434,16 @@ pos_type LyXText::x2pos(pit_type pit, int row, int x) const // x,y are screen coordinates // sets cursor only within this LyXText -void LyXText::setCursorFromCoordinates(LCursor & cur, int const x, int const y) +bool LyXText::setCursorFromCoordinates(LCursor & cur, int const x, int const y) { pit_type pit = getPitNearY(y); int yy = theCoords.get(this, pit).y_ - pars_[pit].ascent(); lyxerr[Debug::DEBUG] - << BOOST_CURRENT_FUNCTION - << ": x: " << x - << " y: " << y + << BOOST_CURRENT_FUNCTION + << ": x: " << x + << " y: " << y << " pit: " << pit - << " yy: " << yy << endl; + << " yy: " << yy << endl; Paragraph const & par = pars_[pit]; int r = 0; @@ -2330,20 +2458,20 @@ void LyXText::setCursorFromCoordinates(LCursor & cur, int const x, int const y) Row const & row = par.rows()[r]; lyxerr[Debug::DEBUG] - << BOOST_CURRENT_FUNCTION - << ": row " << r - << " from pos: " << row.pos() - << endl; + << BOOST_CURRENT_FUNCTION + << ": row " << r + << " from pos: " << row.pos() + << endl; bool bound = false; int xx = x; pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound); - lyxerr[Debug::DEBUG] - << BOOST_CURRENT_FUNCTION - << ": setting cursor pit: " << pit - << " pos: " << pos - << endl; - - setCursor(cur, pit, pos, true, bound); + lyxerr[Debug::DEBUG] + << BOOST_CURRENT_FUNCTION + << ": setting cursor pit: " << pit + << " pos: " << pos + << endl; + + return setCursor(cur, pit, pos, true, bound); }