X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=9a668d4bfc28e2c7a60e356628d520eba8b619b5;hb=f3a750ab9393d891e9f2610ce06874ce1d1353ee;hp=05c612da29cd1006b40232fff5e2aaec164f0f87;hpb=b0eb70e869128e30ab7e4538aa32a244fd4cea57;p=lyx.git diff --git a/src/text.C b/src/text.C index 05c612da29..9a668d4bfc 100644 --- a/src/text.C +++ b/src/text.C @@ -18,9 +18,11 @@ #include "lyxtext.h" +#include "author.h" #include "buffer.h" #include "bufferparams.h" #include "BufferView.h" +#include "cursor.h" #include "debug.h" #include "dispatchresult.h" #include "encoding.h" @@ -29,6 +31,7 @@ #include "language.h" #include "LColor.h" #include "lyxlength.h" +#include "lyxlex.h" #include "lyxrc.h" #include "lyxrow.h" #include "lyxrow_funcs.h" @@ -37,7 +40,6 @@ #include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "rowpainter.h" -#include "text_funcs.h" #include "undo.h" #include "vspace.h" #include "WordLangTuple.h" @@ -49,34 +51,48 @@ #include "support/lstrings.h" #include "support/textutils.h" - -using bv_funcs::number; +#include "support/tostr.h" +#include "support/std_sstream.h" using lyx::pos_type; using lyx::word_location; +using lyx::support::bformat; using lyx::support::contains; using lyx::support::lowercase; +using lyx::support::split; using lyx::support::uppercase; +using std::advance; +using std::distance; using std::max; +using std::min; using std::endl; using std::string; -/// top, right, bottom pixel margin -extern int const PAPER_MARGIN = 20; +/// some space for drawing the 'nested' markers (in pixel) +extern int const NEST_MARGIN = 20; /// margin for changebar extern int const CHANGEBAR_MARGIN = 10; -/// left margin -extern int const LEFT_MARGIN = PAPER_MARGIN + CHANGEBAR_MARGIN; - +/// right margin +extern int const RIGHT_MARGIN = 10; -int bibitemMaxWidth(BufferView *, LyXFont const &); +namespace { +int numberOfSeparators(Paragraph const & par, Row const & row) +{ + pos_type const first = max(row.pos(), par.beginOfBody()); + pos_type const last = row.endpos() - 1; + int n = 0; + for (pos_type p = first; p < last; ++p) { + if (par.isSeparator(p)) + ++n; + } + return n; +} -namespace { unsigned int maxParagraphWidth(ParagraphList const & plist) { @@ -88,6 +104,49 @@ unsigned int maxParagraphWidth(ParagraphList const & plist) return width; } + +int numberOfLabelHfills(Paragraph const & par, Row const & row) +{ + pos_type last = row.endpos() - 1; + pos_type first = row.pos(); + + // hfill *DO* count at the beginning of paragraphs! + if (first) { + while (first < last && par.isHfill(first)) + ++first; + } + + last = min(last, par.beginOfBody()); + int n = 0; + for (pos_type p = first; p < last; ++p) { + if (par.isHfill(p)) + ++n; + } + return n; +} + + +int numberOfHfills(Paragraph const & par, Row const & row) +{ + pos_type const last = row.endpos() - 1; + pos_type first = row.pos(); + + // hfill *DO* count at the beginning of paragraphs! + if (first) { + while (first < last && par.isHfill(first)) + ++first; + } + + first = max(first, par.beginOfBody()); + + int n = 0; + for (pos_type p = first; p < last; ++p) { + if (par.isHfill(p)) + ++n; + } + return n; +} + } // namespace anon @@ -113,10 +172,10 @@ BufferView * LyXText::bv() const } -void LyXText::updateRowPositions() +void LyXText::updateParPositions() { - ParagraphList::iterator pit = ownerParagraphs().begin(); - ParagraphList::iterator end = ownerParagraphs().end(); + ParagraphList::iterator pit = paragraphs().begin(); + ParagraphList::iterator end = paragraphs().end(); for (height = 0; pit != end; ++pit) { pit->y = height; height += pit->height; @@ -124,54 +183,19 @@ void LyXText::updateRowPositions() } -int LyXText::workWidth() const +int LyXText::textWidth() const { - return inset_owner ? inset_owner->textWidth() : bv()->workWidth(); -} - - -int LyXText::getRealCursorX() const -{ - int x = cursor.x(); - if (the_locking_inset && the_locking_inset->getLyXText(bv()) != this) - x = the_locking_inset->getLyXText(bv())->getRealCursorX(); - return x; + return textwidth_; } -// This is the comments that some of the warnings below refers to. -// There are some issues in this file and I don't think they are -// really related to the FIX_DOUBLE_SPACE patch. I'd rather think that -// this is a problem that has been here almost from day one and that a -// larger userbase with different access patters triggers the bad -// behaviour. (segfaults.) What I think happen is: In several places -// we store the paragraph in the current cursor and then moves the -// cursor. This movement of the cursor will delete paragraph at the -// old position if it is now empty. This will make the temporary -// pointer to the old cursor paragraph invalid and dangerous to use. -// And is some cases this will trigger a segfault. I have marked some -// of the cases where this happens with a warning, but I am sure there -// are others in this file and in text2.C. There is also a note in -// Delete() that you should read. In Delete I store the paragraph->id -// instead of a pointer to the paragraph. I am pretty sure this faulty -// use of temporary pointers to paragraphs that might have gotten -// invalidated (through a cursor movement) before they are used, are -// the cause of the strange crashes we get reported often. -// -// It is very tiresom to change this code, especially when it is as -// hard to read as it is. Help to fix all the cases where this is done -// would be greately appreciated. -// -// Lgb - int LyXText::singleWidth(ParagraphList::iterator pit, pos_type pos) const { if (pos >= pit->size()) return 0; char const c = pit->getChar(pos); - LyXFont const & font = getFont(pit, pos); - return singleWidth(pit, pos, c, font); + return singleWidth(pit, pos, c, getFont(pit, pos)); } @@ -210,7 +234,13 @@ int LyXText::singleWidth(ParagraphList::iterator pit, } -int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const +int LyXText::leftMargin(ParagraphList::iterator pit) const +{ + return leftMargin(pit, pit->size()); +} + + +int LyXText::leftMargin(ParagraphList::iterator pit, pos_type pos) const { LyXTextClass const & tclass = bv()->buffer()->params().getLyXTextClass(); @@ -218,19 +248,19 @@ int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const string parindent = layout->parindent; - int x = LEFT_MARGIN; + int x = NEST_MARGIN + CHANGEBAR_MARGIN; x += font_metrics::signedWidth(tclass.leftmargin(), tclass.defaultfont()); - // this is the way, LyX handles the LaTeX-Environments. + // This is the way LyX handles LaTeX-Environments. // I have had this idea very late, so it seems to be a // later added hack and this is true if (pit->getDepth() == 0) { if (pit->layout() == tclass.defaultLayout()) { // find the previous same level paragraph - if (pit != ownerParagraphs().begin()) { + if (pit != paragraphs().begin()) { ParagraphList::iterator newpit = - depthHook(pit, ownerParagraphs(), pit->getDepth()); + depthHook(pit, paragraphs(), pit->getDepth()); if (newpit == pit && newpit->layout()->nextnoindent) parindent.erase(); } @@ -238,16 +268,16 @@ int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const } else { // find the next level paragraph ParagraphList::iterator newpar = - outerHook(pit, ownerParagraphs()); + outerHook(pit, paragraphs()); - // make a corresponding row. Needed to call leftMargin() - // check wether it is a sufficent paragraph - if (newpar != ownerParagraphs().end() + // Make a corresponding row. Need to call leftMargin() + // to check whether it is a sufficent paragraph. + if (newpar != paragraphs().end() && newpar->layout()->isEnvironment()) { - x = leftMargin(newpar, Row(newpar->size())); + x = leftMargin(newpar); } - if (newpar != ownerParagraphs().end() + if (newpar != paragraphs().end() && pit->layout() == tclass.defaultLayout()) { if (newpar->params().noindent()) parindent.erase(); @@ -274,7 +304,7 @@ int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const case MARGIN_MANUAL: x += font_metrics::signedWidth(layout->labelindent, labelfont); // The width of an empty par, even with manual label, should be 0 - if (!pit->empty() && row.pos() >= pit->beginningOfBody()) { + if (!pit->empty() && pos >= pit->beginOfBody()) { if (!pit->getLabelWidthString().empty()) { x += font_metrics::width(pit->getLabelWidthString(), labelfont); @@ -290,19 +320,19 @@ int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const case MARGIN_FIRST_DYNAMIC: if (layout->labeltype == LABEL_MANUAL) { - if (row.pos() >= pit->beginningOfBody()) { + if (pos >= pit->beginOfBody()) { x += font_metrics::signedWidth(layout->leftmargin, labelfont); } else { x += font_metrics::signedWidth(layout->labelindent, labelfont); } - } else if (row.pos() + } else if (pos != 0 // Special case to fix problems with // theorems (JMarc) || (layout->labeltype == LABEL_STATIC && layout->latextype == LATEX_ENVIRONMENT - && !isFirstInSequence(pit, ownerParagraphs()))) { + && !isFirstInSequence(pit, paragraphs()))) { x += font_metrics::signedWidth(layout->leftmargin, labelfont); } else if (layout->labeltype != LABEL_TOP_ENVIRONMENT @@ -318,28 +348,28 @@ int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const break; case MARGIN_RIGHT_ADDRESS_BOX: { +#if 0 // ok, a terrible hack. The left margin depends on the widest // row in this paragraph. RowList::iterator rit = pit->rows.begin(); RowList::iterator end = pit->rows.end(); #warning This is wrong. - int minfill = workWidth() / 2; + int minfill = textwidth_; for ( ; rit != end; ++rit) if (rit->fill() < minfill) minfill = rit->fill(); x += font_metrics::signedWidth(layout->leftmargin, tclass.defaultfont()); x += minfill; +#endif + // also wrong, but much shorter. + x += textwidth_ / 2; + break; } - break; } - if (workWidth() > 0 && !pit->params().leftIndent().zero()) { - LyXLength const len = pit->params().leftIndent(); - int const tw = inset_owner ? - inset_owner->latexTextWidth(bv()) : workWidth(); - x += len.inPixels(tw); - } + if (!pit->params().leftIndent().zero()) + x += pit->params().leftIndent().inPixels(textWidth()); LyXAlignment align; @@ -349,58 +379,52 @@ int LyXText::leftMargin(ParagraphList::iterator pit, Row const & row) const align = pit->params().align(); // set the correct parindent - if (row.pos() == 0) { - if ((layout->labeltype == LABEL_NO_LABEL - || layout->labeltype == LABEL_TOP_ENVIRONMENT - || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT - || (layout->labeltype == LABEL_STATIC - && layout->latextype == LATEX_ENVIRONMENT - && !isFirstInSequence(pit, ownerParagraphs()))) - && align == LYX_ALIGN_BLOCK - && !pit->params().noindent() - // in tabulars and ert paragraphs are never indented! - && (!pit->inInset() || !pit->inInset()->owner() || - (pit->inInset()->owner()->lyxCode() != InsetOld::TABULAR_CODE && - pit->inInset()->owner()->lyxCode() != InsetOld::ERT_CODE)) - && (pit->layout() != tclass.defaultLayout() || - bv()->buffer()->params().paragraph_separation == - BufferParams::PARSEP_INDENT)) { - x += font_metrics::signedWidth(parindent, - tclass.defaultfont()); - } else if (layout->labeltype == LABEL_BIBLIO) { - // ale970405 Right width for bibitems - x += bibitemMaxWidth(bv(), tclass.defaultfont()); - } + if (pos == 0 + && (layout->labeltype == LABEL_NO_LABEL + || layout->labeltype == LABEL_TOP_ENVIRONMENT + || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT + || (layout->labeltype == LABEL_STATIC + && layout->latextype == LATEX_ENVIRONMENT + && !isFirstInSequence(pit, paragraphs()))) + && align == LYX_ALIGN_BLOCK + && !pit->params().noindent() + // in tabulars and ert paragraphs are never indented! + && (!pit->inInset() + || !pit->inInset()->owner() + || (pit->inInset()->owner()->lyxCode() != InsetOld::TABULAR_CODE + && pit->inInset()->owner()->lyxCode() != InsetOld::ERT_CODE)) + && (pit->layout() != tclass.defaultLayout() + || bv()->buffer()->params().paragraph_separation == + BufferParams::PARSEP_INDENT)) + { + x += font_metrics::signedWidth(parindent, tclass.defaultfont()); } return x; } -int LyXText::rightMargin(Paragraph const & par, Buffer const & buf) const +int LyXText::rightMargin(Paragraph const & par) const { - LyXTextClass const & tclass = buf.params().getLyXTextClass(); - LyXLayout_ptr const & layout = par.layout(); + LyXTextClass const & tclass = bv()->buffer()->params().getLyXTextClass(); - return PAPER_MARGIN + return + RIGHT_MARGIN + font_metrics::signedWidth(tclass.rightmargin(), tclass.defaultfont()) - + font_metrics::signedWidth(layout->rightmargin, + + font_metrics::signedWidth(par.layout()->rightmargin, tclass.defaultfont()) * 4 / (par.getDepth() + 4); } -int LyXText::labelEnd(ParagraphList::iterator pit, Row const & row) const +int LyXText::labelEnd(ParagraphList::iterator pit) const { // labelEnd is only needed if the layout fills a flushleft label. if (pit->layout()->margintype != MARGIN_MANUAL) return 0; - - Row tmprow = row; - tmprow.pos(pit->size()); // return the beginning of the body - return leftMargin(pit, tmprow); + return leftMargin(pit); } @@ -430,12 +454,8 @@ void LyXText::rowBreakPoint(ParagraphList::iterator pit, Row & row) const return; } - // maximum pixel width of a row. - int width = workWidth() - rightMargin(*pit, *bv()->buffer()); -// - leftMargin(pit, row); - - // inset->textWidth() returns -1 via workWidth(), - // but why ? + // maximum pixel width of a row + int width = textWidth() - rightMargin(*pit); // - leftMargin(pit, row); if (width < 0) { row.endpos(end); return; @@ -448,14 +468,14 @@ void LyXText::rowBreakPoint(ParagraphList::iterator pit, Row & row) const return; } - pos_type const body_pos = pit->beginningOfBody(); + pos_type const body_pos = pit->beginOfBody(); // Now we iterate through until we reach the right margin // or the end of the par, then choose the possible break // nearest that. - int const left = leftMargin(pit, row); + int const left = leftMargin(pit, pos); int x = left; // pixel width since last breakpoint @@ -475,14 +495,12 @@ void LyXText::rowBreakPoint(ParagraphList::iterator pit, Row & row) const } // Break before... if (i + 1 < end) { - InsetOld * in = pit->getInset(i + 1); - if (in && in->display()) { + if (pit->isInset(i + 1) && pit->getInset(i + 1)->display()) { point = i + 1; break; } // ...and after. - in = pit->getInset(i); - if (in && in->display()) { + if (pit->isInset(i) && pit->getInset(i)->display()) { point = i + 1; break; } @@ -504,37 +522,30 @@ void LyXText::rowBreakPoint(ParagraphList::iterator pit, Row & row) const if (pit->isLineSeparator(i - 1)) add -= singleWidth(pit, i - 1); - add = std::max(add, labelEnd(pit, row) - x); + add = std::max(add, labelEnd(pit) - x); thiswidth += add; } x += thiswidth; - //lyxerr << "i: " << i << " x: " - //<< x << " width: " << width << endl; chunkwidth += thiswidth; } - // break before a character that will fall off // the right of the row if (x >= width) { // if no break before, break here if (point == end || chunkwidth >= width - left) { - if (i > pos) { + if (i > pos) point = i; - break; - } + else + point = i + 1; + } // exit on last registered breakpoint: -#if 0 - // hack removed: - if (i + 1 < end) -#endif break; } - InsetOld * in = pit->getInset(i); - if (!in || in->isChar()) { + if (!pit->isInset(i) || pit->getInset(i)->isChar()) { // some insets are line separators too if (pit->isLineSeparator(i)) { // register breakpoint: @@ -544,13 +555,6 @@ void LyXText::rowBreakPoint(ParagraphList::iterator pit, Row & row) const } } -#if 0 - // hack removed (connected with the #if 0 above): - if (point == end && i != end && x >= width) { - // didn't find one, break at the point we reached the edge - point = i + 1; - } else -#endif if (i == end && x < width) { // maybe found one, but the par is short enough. point = end; @@ -566,16 +570,15 @@ void LyXText::rowBreakPoint(ParagraphList::iterator pit, Row & row) const } -// returns the minimum space a row needs on the screen in pixel -void LyXText::fill(ParagraphList::iterator pit, Row & row, int workwidth) const +void LyXText::setRowWidth(ParagraphList::iterator pit, Row & row) const { // get the pure distance pos_type const end = row.endpos(); - LyXLayout_ptr const & layout = pit->layout(); - int w = leftMargin(pit, row); + string labelsep = pit->layout()->labelsep; + int w = leftMargin(pit, row.pos()); - pos_type const body_pos = pit->beginningOfBody(); + pos_type const body_pos = pit->beginOfBody(); pos_type i = row.pos(); if (i < end) { @@ -584,10 +587,10 @@ void LyXText::fill(ParagraphList::iterator pit, Row & row, int workwidth) const lyx::pos_type endPosOfFontSpan = pit->getEndPosOfFontSpan(i); for ( ; i < end; ++i) { if (body_pos > 0 && i == body_pos) { - w += font_metrics::width(layout->labelsep, getLabelFont(pit)); + w += font_metrics::width(labelsep, getLabelFont(pit)); if (pit->isLineSeparator(i - 1)) w -= singleWidth(pit, i - 1); - w = max(w, labelEnd(pit, row)); + w = max(w, labelEnd(pit)); } char const c = pit->getChar(i); if (IsPrintable(c) && i > endPosOfFontSpan) { @@ -600,22 +603,20 @@ void LyXText::fill(ParagraphList::iterator pit, Row & row, int workwidth) const } if (body_pos > 0 && body_pos >= end) { - w += font_metrics::width(layout->labelsep, getLabelFont(pit)); + w += font_metrics::width(labelsep, getLabelFont(pit)); if (end > 0 && pit->isLineSeparator(end - 1)) w -= singleWidth(pit, end - 1); - w = max(w, labelEnd(pit, row)); + w = max(w, labelEnd(pit)); } - int const fill = workwidth - w - rightMargin(*pit, *bv()->buffer()); - row.fill(fill); - row.width(workwidth - fill); + row.width(w + rightMargin(*pit)); } // returns the minimum space a manual label needs on the screen in pixel int LyXText::labelFill(ParagraphList::iterator pit, Row const & row) const { - pos_type last = pit->beginningOfBody(); + pos_type last = pit->beginOfBody(); BOOST_ASSERT(last > 0); @@ -640,9 +641,7 @@ int LyXText::labelFill(ParagraphList::iterator pit, Row const & row) const LColor_color LyXText::backgroundColor() const { - if (inset_owner) - return inset_owner->backgroundColor(); - return LColor::background; + return LColor_color(LColor::color(background_color_)); } @@ -658,9 +657,10 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) // are taken from the layoutfont. Nicer on the screen :) LyXLayout_ptr const & layout = pit->layout(); - // as max get the first character of this row then it can increase but not - // decrease the height. Just some point to start with so we don't have to - // do the assignment below too often. + // as max get the first character of this row then it can + // increase but not decrease the height. Just some point to + // start with so we don't have to do the assignment below too + // often. LyXFont font = getFont(pit, row.pos()); LyXFont::FONT_SIZE const tmpsize = font.size(); font = getLayoutFont(pit); @@ -711,7 +711,7 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) // some parksips VERY EASY IMPLEMENTATION if (bv()->buffer()->params().paragraph_separation == BufferParams::PARSEP_SKIP - && pit != ownerParagraphs().begin() + && pit != paragraphs().begin() && ((layout->isParagraph() && pit->getDepth() == 0) || (boost::prior(pit)->layout()->isParagraph() && boost::prior(pit)->getDepth() == 0))) @@ -719,13 +719,6 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) maxasc += bufparams.getDefSkip().inPixels(*bv()); } - // the top margin - if (pit == ownerParagraphs().begin() && !isInInset()) - maxasc += PAPER_MARGIN; - - // add user added vertical space - maxasc += getLengthMarkerHeight(*bv(), pit->params().spaceTop()); - if (pit->params().startOfAppendix()) maxasc += int(3 * dh); @@ -740,7 +733,7 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) if ((layout->labeltype == LABEL_TOP_ENVIRONMENT || layout->labeltype == LABEL_BIBLIO || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) - && isFirstInSequence(pit, ownerParagraphs()) + && isFirstInSequence(pit, paragraphs()) && !pit->getLabelstring().empty()) { labeladdon = int( @@ -750,27 +743,27 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) + (layout->topsep + layout->labelbottomsep) * dh); } - // And now the layout spaces, for example before and after + // Add the layout spaces, for example before and after // a section, or between the items of a itemize or enumerate // environment. ParagraphList::iterator prev = - depthHook(pit, ownerParagraphs(), pit->getDepth()); + depthHook(pit, paragraphs(), pit->getDepth()); if (prev != pit && prev->layout() == layout && prev->getDepth() == pit->getDepth() && prev->getLabelWidthString() == pit->getLabelWidthString()) { layoutasc = layout->itemsep * dh; - } else if (pit != ownerParagraphs().begin() || row.pos() != 0) { + } else if (pit != paragraphs().begin() || row.pos() != 0) { if (layout->topsep > 0) layoutasc = layout->topsep * dh; } - prev = outerHook(pit, ownerParagraphs()); - if (prev != ownerParagraphs().end()) { + prev = outerHook(pit, paragraphs()); + if (prev != paragraphs().end()) { maxasc += int(prev->layout()->parsep * dh); - } else if (pit != ownerParagraphs().begin()) { + } else if (pit != paragraphs().begin()) { ParagraphList::iterator prior_pit = boost::prior(pit); if (prior_pit->getDepth() != 0 || prior_pit->layout() == layout) { @@ -781,25 +774,18 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) // is it a bottom line? if (row.endpos() >= pit->size()) { - // the bottom margin - ParagraphList::iterator nextpit = boost::next(pit); - if (nextpit == ownerParagraphs().end() && !isInInset()) - maxdesc += PAPER_MARGIN; - - // add the vertical spaces, that the user added - maxdesc += getLengthMarkerHeight(*bv(), pit->params().spaceBottom()); - - // and now the layout spaces, for example before and after + // add the layout spaces, for example before and after // a section, or between the items of a itemize or enumerate // environment - if (nextpit != ownerParagraphs().end()) { + ParagraphList::iterator nextpit = boost::next(pit); + if (nextpit != paragraphs().end()) { ParagraphList::iterator cpit = pit; double usual = 0; double unusual = 0; if (cpit->getDepth() > nextpit->getDepth()) { usual = cpit->layout()->bottomsep * dh; - cpit = depthHook(cpit, ownerParagraphs(), nextpit->getDepth()); + cpit = depthHook(cpit, paragraphs(), nextpit->getDepth()); if (cpit->layout() != nextpit->layout() || nextpit->getLabelWidthString() != cpit->getLabelWidthString()) { @@ -824,31 +810,34 @@ void LyXText::setHeightOfRow(ParagraphList::iterator pit, Row & row) } -void LyXText::breakParagraph(ParagraphList & paragraphs, char keep_layout) +void LyXText::breakParagraph(LCursor & cur, char keep_layout) { + BOOST_ASSERT(this == cur.text()); // allow only if at start or end, or all previous is new text - ParagraphList::iterator cpit = cursorPar(); - if (cursor.pos() && cursor.pos() != cpit->size() - && cpit->isChangeEdited(0, cursor.pos())) + Paragraph & cpar = cur.paragraph(); + ParagraphList::iterator cpit = getPar(cur.par()); + + if (cur.pos() != 0 && cur.pos() != cur.lastpos() + && cpar.isChangeEdited(0, cur.pos())) return; LyXTextClass const & tclass = bv()->buffer()->params().getLyXTextClass(); - LyXLayout_ptr const & layout = cpit->layout(); + LyXLayout_ptr const & layout = cpar.layout(); - // this is only allowed, if the current paragraph is not empty or caption - // and if it has not the keepempty flag active - if (cpit->empty() && !cpit->allowEmpty() + // this is only allowed, if the current paragraph is not empty + // or caption and if it has not the keepempty flag active + if (cur.lastpos() == 0 && !cpar.allowEmpty() && layout->labeltype != LABEL_SENSITIVE) return; - recUndo(cursor.par()); + // a layout change may affect also the following paragraph + recUndo(cur.par(), parOffset(undoSpan(cpit)) - 1); // Always break behind a space - // // It is better to erase the space (Dekel) - if (cursor.pos() < cpit->size() && cpit->isLineSeparator(cursor.pos())) - cpit->erase(cursor.pos()); + if (cur.pos() != cur.lastpos() && cpar.isLineSeparator(cur.pos())) + cpar.erase(cur.pos()); // break the paragraph if (keep_layout) @@ -860,20 +849,16 @@ void LyXText::breakParagraph(ParagraphList & paragraphs, char keep_layout) // breakParagraph call should return a bool if it inserts the // paragraph before or behind and we should react on that one // but we can fix this in 1.3.0 (Jug 20020509) - bool const isempty = cpit->allowEmpty() && cpit->empty(); - ::breakParagraph(bv()->buffer()->params(), paragraphs, cpit, - cursor.pos(), keep_layout); - -#warning Trouble Point! (Lgb) - // When ::breakParagraph is called from within an inset we must - // ensure that the correct ParagraphList is used. Today that is not - // the case and the Buffer::paragraphs is used. Not good. (Lgb) - cpit = cursorPar(); + bool const isempty = cpar.allowEmpty() && cpar.empty(); + ::breakParagraph(bv()->buffer()->params(), paragraphs(), cpit, + cur.pos(), keep_layout); + + cpit = getPar(cur.par()); ParagraphList::iterator next_par = boost::next(cpit); // well this is the caption hack since one caption is really enough if (layout->labeltype == LABEL_SENSITIVE) { - if (!cursor.pos()) + if (!cur.pos()) // set to standard-layout cpit->applyLayout(tclass.defaultLayout()); else @@ -885,11 +870,10 @@ void LyXText::breakParagraph(ParagraphList & paragraphs, char keep_layout) // move one row up! // This touches only the screen-update. Otherwise we would may have // an empty row on the screen - RowList::iterator crit = cpit->getRow(cursor.pos()); - if (cursor.pos() && crit->pos() == cursor.pos() - && !cpit->isNewline(cursor.pos() - 1)) + if (cur.pos() != 0 && cur.textRow().pos() == cur.pos() + && !cpit->isNewline(cur.pos() - 1)) { - cursorLeft(bv()); + cursorLeft(cur); } while (!next_par->empty() && next_par->isNewline(0)) @@ -901,33 +885,36 @@ void LyXText::breakParagraph(ParagraphList & paragraphs, char keep_layout) // This check is necessary. Otherwise the new empty paragraph will // be deleted automatically. And it is more friendly for the user! - if (cursor.pos() || isempty) - setCursor(next_par, 0); + if (cur.pos() != 0 || isempty) + setCursor(cur, cur.par() + 1, 0); else - setCursor(cpit, 0); + setCursor(cur, cur.par(), 0); } // convenience function -void LyXText::redoParagraph() +void LyXText::redoParagraph(LCursor & cur) { - clearSelection(); - redoParagraph(cursorPar()); - setCursorIntern(cursor.par(), cursor.pos()); + BOOST_ASSERT(this == cur.text()); + cur.clearSelection(); + redoParagraph(getPar(cur.par())); + setCursorIntern(cur, cur.par(), cur.pos()); } // insert a character, moves all the following breaks in the // same Paragraph one to the right and make a rebreak -void LyXText::insertChar(char c) +void LyXText::insertChar(LCursor & cur, char c) { - recordUndo(Undo::INSERT, this, cursor.par(), cursor.par()); + BOOST_ASSERT(this == cur.text()); + recordUndo(cur, Undo::INSERT); - // When the free-spacing option is set for the current layout, - // disable the double-space checking + Paragraph & par = cur.paragraph(); + // try to remove this + ParagraphList::iterator pit = getPar(cur.par()); - bool const freeSpacing = cursorPar()->layout()->free_spacing || - cursorPar()->isFreeSpacing(); + bool const freeSpacing = par.layout()->free_spacing || + par.isFreeSpacing(); if (lyxrc.auto_number) { static string const number_operators = "+-/*"; @@ -937,36 +924,28 @@ void LyXText::insertChar(char c) if (current_font.number() == LyXFont::ON) { if (!IsDigit(c) && !contains(number_operators, c) && !(contains(number_seperators, c) && - cursor.pos() >= 1 && - cursor.pos() < cursorPar()->size() && - getFont(cursorPar(), cursor.pos()).number() == LyXFont::ON && - getFont(cursorPar(), cursor.pos() - 1).number() == LyXFont::ON) + cur.pos() != 0 && + cur.pos() != cur.lastpos() && + getFont(pit, cur.pos()).number() == LyXFont::ON && + getFont(pit, cur.pos() - 1).number() == LyXFont::ON) ) - number(bv()); // Set current_font.number to OFF + number(cur); // Set current_font.number to OFF } else if (IsDigit(c) && real_current_font.isVisibleRightToLeft()) { - number(bv()); // Set current_font.number to ON + number(cur); // Set current_font.number to ON - if (cursor.pos() > 0) { - char const c = cursorPar()->getChar(cursor.pos() - 1); + if (cur.pos() != 0) { + char const c = par.getChar(cur.pos() - 1); if (contains(number_unary_operators, c) && - (cursor.pos() == 1 || - cursorPar()->isSeparator(cursor.pos() - 2) || - cursorPar()->isNewline(cursor.pos() - 2)) + (cur.pos() == 1 + || par.isSeparator(cur.pos() - 2) + || par.isNewline(cur.pos() - 2)) ) { - setCharFont( - cursorPar(), - cursor.pos() - 1, - current_font); - } else if (contains(number_seperators, c) && - cursor.pos() >= 2 && - getFont( - cursorPar(), - cursor.pos() - 2).number() == LyXFont::ON) { - setCharFont( - cursorPar(), - cursor.pos() - 1, - current_font); + setCharFont(pit, cur.pos() - 1, current_font); + } else if (contains(number_seperators, c) + && cur.pos() >= 2 + && getFont(pit, cur.pos() - 2).number() == LyXFont::ON) { + setCharFont(pit, cur.pos() - 1, current_font); } } } @@ -988,36 +967,41 @@ void LyXText::insertChar(char c) 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 ((cursor.pos() > 0 - && cursorPar()->isLineSeparator(cursor.pos() - 1)) - || (cursor.pos() > 0 - && cursorPar()->isNewline(cursor.pos() - 1)) - || (cursor.pos() == 0)) { + if (cur.pos() == 0) { static bool sent_space_message = false; if (!sent_space_message) { - if (cursor.pos() == 0) - bv()->owner()->message(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial.")); - else - bv()->owner()->message(_("You cannot type two spaces this way. Please read the Tutorial.")); + cur.message(_("You cannot insert a space at the " + "beginning of a paragraph. Please read the Tutorial.")); + sent_space_message = true; + return; + } + } + BOOST_ASSERT(cur.pos() > 0); + if (par.isLineSeparator(cur.pos() - 1) + || par.isNewline(cur.pos() - 1)) { + static bool sent_space_message = false; + if (!sent_space_message) { + cur.message(_("You cannot type two spaces this way. " + "Please read the Tutorial.")); sent_space_message = true; } - charInserted(); return; } } // Here case LyXText::InsertInset already inserted the character if (c != Paragraph::META_INSET) - cursorPar()->insertChar(cursor.pos(), c); + par.insertChar(cur.pos(), c); - setCharFont(cursorPar(), cursor.pos(), rawtmpfont); + setCharFont(pit, cur.pos(), rawtmpfont); current_font = rawtmpfont; real_current_font = realtmpfont; - redoParagraph(cursorPar()); - setCursor(cursor.par(), cursor.pos() + 1, false, cursor.boundary()); - + redoParagraph(cur); + setCursor(cur, cur.par(), cur.pos() + 1, false, cur.boundary()); charInserted(); } @@ -1038,18 +1022,17 @@ void LyXText::charInserted() void LyXText::prepareToPrint(ParagraphList::iterator pit, Row & row) const { - double w = row.fill(); + double w = textWidth() - row.width(); double fill_hfill = 0; double fill_label_hfill = 0; double fill_separator = 0; double x = 0; - bool const is_rtl = - pit->isRightToLeftPar(bv()->buffer()->params()); + bool const is_rtl = isRTL(*pit); if (is_rtl) - x = workWidth() > 0 ? rightMargin(*pit, *bv()->buffer()) : 0; + x = rightMargin(*pit); else - x = workWidth() > 0 ? leftMargin(pit, row) : 0; + x = leftMargin(pit, row.pos()); // is there a manual margin with a manual label LyXLayout_ptr const & layout = pit->layout(); @@ -1080,22 +1063,14 @@ void LyXText::prepareToPrint(ParagraphList::iterator pit, Row & row) const // we don't have to look at the alignment if it is ALIGN_LEFT and // if the row is already larger then the permitted width as then // we force the LEFT_ALIGN'edness! - } else if (int(row.width()) < workWidth()) { + } else if (int(row.width()) < textWidth()) { // is it block, flushleft or flushright? // set x how you need it int align; - if (pit->params().align() == LYX_ALIGN_LAYOUT) { + if (pit->params().align() == LYX_ALIGN_LAYOUT) align = layout->align; - } else { + else align = pit->params().align(); - } - // ERT insets should always be LEFT ALIGNED on screen - InsetOld * inset = pit->inInset(); - if (inset && inset->owner() && - inset->owner()->lyxCode() == InsetOld::ERT_CODE) - { - align = LYX_ALIGN_LEFT; - } // Display-style insets should always be on a centred row // The test on pit->size() is to catch zero-size pars, which @@ -1109,32 +1084,32 @@ void LyXText::prepareToPrint(ParagraphList::iterator pit, Row & row) const } switch (align) { - case LYX_ALIGN_BLOCK: { - int const ns = numberOfSeparators(*pit, row); - bool disp_inset = false; - if (row.endpos() < pit->size()) { - InsetOld * in = pit->getInset(row.endpos()); - if (in) - disp_inset = in->display(); - } - // If we have separators, this is not the last row of a - // par, does not end in newline, and is not row above a - // display inset... then stretch it - if (ns - && row.endpos() < pit->size() - && !pit->isNewline(row.endpos() - 1) - && !disp_inset - ) { - fill_separator = w / ns; - } else if (is_rtl) { - x += w; - } - break; + case LYX_ALIGN_BLOCK: { + int const ns = numberOfSeparators(*pit, row); + bool disp_inset = false; + if (row.endpos() < pit->size()) { + InsetBase * in = pit->getInset(row.endpos()); + if (in) + disp_inset = in->display(); + } + // If we have separators, this is not the last row of a + // par, does not end in newline, and is not row above a + // display inset... then stretch it + if (ns + && row.endpos() < pit->size() + && !pit->isNewline(row.endpos() - 1) + && !disp_inset + ) { + fill_separator = w / ns; + } else if (is_rtl) { + x += w; } - case LYX_ALIGN_RIGHT: + break; + } + case LYX_ALIGN_RIGHT: x += w; break; - case LYX_ALIGN_CENTER: + case LYX_ALIGN_CENTER: x += w / 2; break; } @@ -1142,7 +1117,7 @@ void LyXText::prepareToPrint(ParagraphList::iterator pit, Row & row) const bidi.computeTables(*pit, *bv()->buffer(), row); if (is_rtl) { - pos_type body_pos = pit->beginningOfBody(); + pos_type body_pos = pit->beginOfBody(); pos_type end = row.endpos(); if (body_pos > 0 @@ -1161,298 +1136,189 @@ void LyXText::prepareToPrint(ParagraphList::iterator pit, Row & row) const } -// important for the screen - - // the cursor set functions have a special mechanism. When they // realize, that you left an empty paragraph, they will delete it. -// They also delete the corresponding row -void LyXText::cursorRightOneWord() +void LyXText::cursorRightOneWord(LCursor & cur) { - ::cursorRightOneWord(*this, cursor, ownerParagraphs()); - setCursor(cursorPar(), cursor.pos()); + BOOST_ASSERT(this == cur.text()); + if (cur.pos() == cur.lastpos() && cur.par() != cur.lastpar()) { + ++cur.par(); + cur.pos() = 0; + } else { + // Skip through initial nonword stuff. + // Treat floats and insets as words. + while (cur.pos() != cur.lastpos() && !cur.paragraph().isWord(cur.pos())) + ++cur.pos(); + // Advance through word. + while (cur.pos() != cur.lastpos() && cur.paragraph().isWord(cur.pos())) + ++cur.pos(); + } + setCursor(cur, cur.par(), cur.pos()); } -// Skip initial whitespace at end of word and move cursor to *start* -// of prior word, not to end of next prior word. -void LyXText::cursorLeftOneWord() +void LyXText::cursorLeftOneWord(LCursor & cur) { - LyXCursor tmpcursor = cursor; - ::cursorLeftOneWord(*this, tmpcursor, ownerParagraphs()); - setCursor(getPar(tmpcursor), tmpcursor.pos()); + BOOST_ASSERT(this == cur.text()); + if (cur.pos() == 0 && cur.par() != 0) { + --cur.par(); + cur.pos() = cur.lastpos(); + } else { + // Skip through initial nonword stuff. + // Treat floats and insets as words. + while (cur.pos() != 0 && !cur.paragraph().isWord(cur.pos() - 1)) + --cur.pos(); + // Advance through word. + while (cur.pos() != 0 && cur.paragraph().isWord(cur.pos() - 1)) + --cur.pos(); + } + setCursor(cur, cur.par(), cur.pos()); } -void LyXText::selectWord(word_location loc) +void LyXText::selectWord(LCursor & cur, word_location loc) { - LyXCursor from = cursor; - LyXCursor to = cursor; - ::getWord(*this, from, to, loc, ownerParagraphs()); - if (cursor != from) - setCursor(from.par(), from.pos()); + BOOST_ASSERT(this == cur.text()); + CursorSlice from = cur.current(); + CursorSlice to = cur.current(); + getWord(from, to, loc); + if (cur.current() != from) + setCursor(cur, from.par(), from.pos()); if (to == from) return; - selection.cursor = cursor; - setCursor(to.par(), to.pos()); - setSelection(); + cur.resetAnchor(); + setCursor(cur, to.par(), to.pos()); + cur.setSelection(); } // Select the word currently under the cursor when no // selection is currently set -bool LyXText::selectWordWhenUnderCursor(word_location loc) +bool LyXText::selectWordWhenUnderCursor(LCursor & cur, word_location loc) { - if (!selection.set()) { - selectWord(loc); - return selection.set(); - } - return false; + BOOST_ASSERT(this == cur.text()); + if (cur.selection()) + return false; + selectWord(cur, loc); + return cur.selection(); } -void LyXText::acceptChange() +void LyXText::acceptChange(LCursor & cur) { - if (!selection.set() && cursorPar()->size()) + BOOST_ASSERT(this == cur.text()); + if (!cur.selection() && cur.lastpos() != 0) return; - if (selection.start.par() == selection.end.par()) { - LyXCursor & startc = selection.start; - LyXCursor & endc = selection.end; - recordUndo(Undo::INSERT, this, startc.par()); + CursorSlice const & startc = cur.selBegin(); + CursorSlice const & endc = cur.selEnd(); + if (startc.par() == endc.par()) { + recordUndoSelection(cur, Undo::INSERT); getPar(startc)->acceptChange(startc.pos(), endc.pos()); finishUndo(); - clearSelection(); + cur.clearSelection(); redoParagraph(getPar(startc)); - setCursorIntern(startc.par(), 0); + setCursorIntern(cur, startc.par(), 0); } #warning handle multi par selection } -void LyXText::rejectChange() +void LyXText::rejectChange(LCursor & cur) { - if (!selection.set() && cursorPar()->size()) + BOOST_ASSERT(this == cur.text()); + if (!cur.selection() && cur.lastpos() != 0) return; - if (selection.start.par() == selection.end.par()) { - LyXCursor & startc = selection.start; - LyXCursor & endc = selection.end; - recordUndo(Undo::INSERT, this, startc.par()); + CursorSlice const & startc = cur.selBegin(); + CursorSlice const & endc = cur.selEnd(); + if (startc.par() == endc.par()) { + recordUndoSelection(cur, Undo::INSERT); getPar(startc)->rejectChange(startc.pos(), endc.pos()); finishUndo(); - clearSelection(); + cur.clearSelection(); redoParagraph(getPar(startc)); - setCursorIntern(startc.par(), 0); + setCursorIntern(cur, startc.par(), 0); } #warning handle multi par selection } -// This function is only used by the spellchecker for NextWord(). -// It doesn't handle LYX_ACCENTs and probably never will. -WordLangTuple const LyXText::selectNextWordToSpellcheck(float & value) -{ - if (the_locking_inset) { - WordLangTuple word = - the_locking_inset->selectNextWordToSpellcheck(bv(), value); - if (!word.word().empty()) { - value += float(cursor.y()); - value /= float(height); - return word; - } - // we have to go on checking so move cursor to the next char - if (cursor.pos() == cursorPar()->size()) { - if (cursor.par() + 1 == int(ownerParagraphs().size())) - return word; - cursor.par(cursor.par() + 1); - cursor.pos(0); - } else { - cursor.pos(cursor.pos() + 1); - } - } - int const tmppar = cursor.par(); - - // If this is not the very first word, skip rest of - // current word because we are probably in the middle - // of a word if there is text here. - if (cursor.pos() || cursor.par() != 0) { - while (cursor.pos() < cursorPar()->size() - && cursorPar()->isLetter(cursor.pos())) - cursor.pos(cursor.pos() + 1); - } - - // Now, skip until we have real text (will jump paragraphs) - while (true) { - ParagraphList::iterator cpit = cursorPar(); - pos_type const cpos = cursor.pos(); - - if (cpos == cpit->size()) { - if (cursor.par() + 1 != int(ownerParagraphs().size())) { - cursor.par(cursor.par() + 1); - cursor.pos(0); - continue; - } - break; - } - - bool const is_good_inset = cpit->isInset(cpos) - && cpit->getInset(cpos)->allowSpellcheck(); - - if (!isDeletedText(*cpit, cpos) - && (is_good_inset || cpit->isLetter(cpos))) - break; - - cursor.pos(cpos + 1); - } - - // now check if we hit an inset so it has to be a inset containing text! - if (cursor.pos() < cursorPar()->size() && - cursorPar()->isInset(cursor.pos())) { - // lock the inset! - FuncRequest cmd(bv(), LFUN_INSET_EDIT, "left"); - cursorPar()->getInset(cursor.pos())->dispatch(cmd); - // now call us again to do the above trick - // but obviously we have to start from down below ;) - return bv()->text->selectNextWordToSpellcheck(value); - } - - // Update the value if we changed paragraphs - if (cursor.par() != tmppar) { - setCursor(cursor.par(), cursor.pos()); - value = float(cursor.y())/float(height); - } - - // Start the selection from here - selection.cursor = cursor; - - string lang_code = getFont(cursorPar(), cursor.pos()).language()->code(); - // and find the end of the word (insets like optional hyphens - // and ligature break are part of a word) - while (cursor.pos() < cursorPar()->size() - && cursorPar()->isLetter(cursor.pos()) - && !isDeletedText(*cursorPar(), cursor.pos())) - cursor.pos(cursor.pos() + 1); - - // Finally, we copy the word to a string and return it - string str; - if (selection.cursor.pos() < cursor.pos()) { - for (pos_type i = selection.cursor.pos(); i < cursor.pos(); ++i) { - if (!cursorPar()->isInset(i)) - str += cursorPar()->getChar(i); - } - } - return WordLangTuple(str, lang_code); -} - - -// This one is also only for the spellchecker -void LyXText::selectSelectedWord() -{ - if (the_locking_inset) { - the_locking_inset->selectSelectedWord(bv()); - return; - } - // move cursor to the beginning - setCursor(selection.cursor.par(), selection.cursor.pos()); - - // set the sel cursor - selection.cursor = cursor; - - // now find the end of the word - while (cursor.pos() < cursorPar()->size() - && cursorPar()->isLetter(cursor.pos())) - cursor.pos(cursor.pos() + 1); - - setCursor(cursorPar(), cursor.pos()); - - // finally set the selection - setSelection(); -} - - // Delete from cursor up to the end of the current or next word. -void LyXText::deleteWordForward() +void LyXText::deleteWordForward(LCursor & cur) { - if (cursorPar()->empty()) - cursorRight(bv()); + BOOST_ASSERT(this == cur.text()); + if (cur.lastpos() == 0) + cursorRight(cur); else { - LyXCursor tmpcursor = cursor; - selection.set(true); // to avoid deletion - cursorRightOneWord(); - setCursor(tmpcursor, tmpcursor.par(), tmpcursor.pos()); - selection.cursor = cursor; - cursor = tmpcursor; - setSelection(); - cutSelection(true, false); + cur.resetAnchor(); + cur.selection() = true; + cursorRightOneWord(cur); + cur.setSelection(); + cutSelection(cur, true, false); } } // Delete from cursor to start of current or prior word. -void LyXText::deleteWordBackward() +void LyXText::deleteWordBackward(LCursor & cur) { - if (cursorPar()->empty()) - cursorLeft(bv()); + BOOST_ASSERT(this == cur.text()); + if (cur.lastpos() == 0) + cursorLeft(cur); else { - LyXCursor tmpcursor = cursor; - selection.set(true); // to avoid deletion - cursorLeftOneWord(); - setCursor(tmpcursor, tmpcursor.par(), tmpcursor.pos()); - selection.cursor = cursor; - cursor = tmpcursor; - setSelection(); - cutSelection(true, false); + cur.resetAnchor(); + cur.selection() = true; + cursorLeftOneWord(cur); + cur.setSelection(); + cutSelection(cur, true, false); } } // Kill to end of line. -void LyXText::deleteLineForward() +void LyXText::deleteLineForward(LCursor & cur) { - if (cursorPar()->empty()) { + BOOST_ASSERT(this == cur.text()); + if (cur.lastpos() == 0) { // Paragraph is empty, so we just go to the right - cursorRight(bv()); + cursorRight(cur); } else { - LyXCursor tmpcursor = cursor; - // We can't store the row over a regular setCursor - // so we set it to 0 and reset it afterwards. - selection.set(true); // to avoid deletion - cursorEnd(); - setCursor(tmpcursor, tmpcursor.par(), tmpcursor.pos()); - selection.cursor = cursor; - cursor = tmpcursor; - setSelection(); + cur.resetAnchor(); + cur.selection() = true; // to avoid deletion + cursorEnd(cur); + cur.setSelection(); // What is this test for ??? (JMarc) - if (!selection.set()) - deleteWordForward(); + if (!cur.selection()) + deleteWordForward(cur); else - cutSelection(true, false); + cutSelection(cur, true, false); } } -void LyXText::changeCase(LyXText::TextCase action) +void LyXText::changeCase(LCursor & cur, LyXText::TextCase action) { - LyXCursor from; - LyXCursor to; + BOOST_ASSERT(this == cur.text()); + CursorSlice from; + CursorSlice to; - if (selection.set()) { - from = selection.start; - to = selection.end; + if (cur.selection()) { + from = cur.selBegin(); + to = cur.selEnd(); } else { - from = cursor; - ::getWord(*this, from, to, lyx::PARTIAL_WORD, ownerParagraphs()); - setCursor(to.par(), to.pos() + 1); + from = cursor(); + getWord(from, to, lyx::PARTIAL_WORD); + setCursor(cur, to.par(), to.pos() + 1); } - recordUndo(Undo::ATOMIC, this, from.par(), to.par()); + recordUndoSelection(cur); pos_type pos = from.pos(); int par = from.par(); - while (par != int(ownerParagraphs().size()) && + while (par != int(paragraphs().size()) && (pos != to.pos() || par != to.par())) { ParagraphList::iterator pit = getPar(par); if (pos == pit->size()) { @@ -1482,91 +1348,62 @@ void LyXText::changeCase(LyXText::TextCase action) } -void LyXText::Delete() +void LyXText::Delete(LCursor & cur) { - // this is a very easy implementation - - LyXCursor old_cursor = cursor; - int const old_cur_par_id = cursorPar()->id(); - int const old_cur_par_prev_id = - old_cursor.par() ? getPar(old_cursor.par() - 1)->id() : -1; - - // just move to the right - cursorRight(bv()); - - // CHECK Look at the comment here. - // This check is not very good... - // The cursorRightIntern calls DeleteEmptyParagraphMechanism - // and that can very well delete the par or par->previous in - // old_cursor. Will a solution where we compare paragraph id's - //work better? - int iid = cursor.par() ? getPar(cursor.par() - 1)->id() : -1; - if (iid == old_cur_par_prev_id && cursorPar()->id() != old_cur_par_id) { - // delete-empty-paragraph-mechanism has done it - return; - } - - // if you had success make a backspace - if (old_cursor.par() != cursor.par() || old_cursor.pos() != cursor.pos()) { - recordUndo(Undo::DELETE, this, old_cursor.par()); - backspace(); + BOOST_ASSERT(this == cur.text()); + // just move to the right, if we had success make a backspace + CursorSlice sl = cur.current(); + cursorRight(cur); + if (sl == cur.current()) { + recordUndo(cur, Undo::DELETE, cur.par(), max(0, cur.par() - 1)); + backspace(cur); } } -void LyXText::backspace() +void LyXText::backspace(LCursor & cur) { - // Get the font that is used to calculate the baselineskip - ParagraphList::iterator pit = cursorPar(); - pos_type lastpos = pit->size(); - - if (cursor.pos() == 0) { - // The cursor is at the beginning of a paragraph, - // so the the backspace will collapse two paragraphs into one. + 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. // but it's not allowed unless it's new - if (pit->isChangeEdited(0, pit->size())) + Paragraph & par = cur.paragraph(); + if (par.isChangeEdited(0, par.size())) return; // we may paste some paragraphs // is it an empty paragraph? - - if (lastpos == 0 || (lastpos == 1 && pit->isSeparator(0))) { + 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 (cursor.par()) { - ParagraphList::iterator tmppit = getPar(cursor.par() - 1); - if (cursorPar()->layout() == tmppit->layout() - && cursorPar()->getAlign() == tmppit->getAlign()) { - // Inherit bottom DTD from the paragraph below. - // (the one we are deleting) - tmppit->params().spaceBottom(cursorPar()->params().spaceBottom()); - } - - cursorLeft(bv()); - + if (cur.par() != 0) { + cursorLeft(cur); // the layout things can change the height of a row ! - redoParagraph(); + redoParagraph(cur); return; } } - if (cursor.par() != 0) - recordUndo(Undo::DELETE, this, cursor.par() - 1, cursor.par()); + if (cur.par() != 0) + recordUndo(cur, Undo::DELETE, cur.par() - 1); - ParagraphList::iterator tmppit = cursorPar(); + ParagraphList::iterator tmppit = getPar(cur.par()); // 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 (cursor.par() != 0) { + if (cur.par() != 0) { // steps into the above paragraph. - setCursorIntern(cursor.par() - 1, - getPar(cursor.par() - 1)->size(), + setCursorIntern(cur, cur.par() - 1, + getPar(cur.par() - 1)->size(), false); } @@ -1577,7 +1414,7 @@ void LyXText::backspace() Buffer & buf = *bv()->buffer(); BufferParams const & bufparams = buf.params(); LyXTextClass const & tclass = bufparams.getLyXTextClass(); - ParagraphList::iterator const cpit = cursorPar(); + ParagraphList::iterator const cpit = getPar(cur.par()); if (cpit != tmppit && (cpit->layout() == tmppit->layout() @@ -1585,52 +1422,43 @@ void LyXText::backspace() && cpit->getAlign() == tmppit->getAlign()) { mergeParagraph(bufparams, buf.paragraphs(), cpit); - if (cursor.pos() && cpit->isSeparator(cursor.pos() - 1)) - cursor.pos(cursor.pos() - 1); + if (cur.pos() != 0 && cpit->isSeparator(cur.pos() - 1)) + --cur.pos(); // the counters may have changed updateCounters(); - setCursor(cursor.par(), cursor.pos(), false); + setCursor(cur, cur.par(), cur.pos(), false); } } else { // this is the code for a normal backspace, not pasting // any paragraphs - recordUndo(Undo::DELETE, this, cursor.par()); + recordUndo(cur, Undo::DELETE); // 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) - setCursorIntern(cursor.par(), cursor.pos() - 1, - false, cursor.boundary()); - cursorPar()->erase(cursor.pos()); + setCursorIntern(cur, cur.par(), cur.pos() - 1, + false, cur.boundary()); + cur.paragraph().erase(cur.pos()); } - lastpos = cursorPar()->size(); - if (cursor.pos() == lastpos) - setCurrentFont(); + if (cur.pos() == cur.lastpos()) + setCurrentFont(cur); - redoParagraph(); - setCursor(cursor.par(), cursor.pos(), false, cursor.boundary()); + redoParagraph(cur); + setCursor(cur, cur.par(), cur.pos(), false, cur.boundary()); } ParagraphList::iterator LyXText::cursorPar() const { - if (cursor.par() != cache_pos_) { - cache_pos_ = cursor.par(); - cache_par_ = getPar(cache_pos_); - } - return cache_par_; -} - - -RowList::iterator LyXText::cursorRow() const -{ - return cursorPar()->getRow(cursor.pos()); + //lyxerr << "### cursorPar: cursor: " << bv()->cursor() << endl; + //lyxerr << "xxx cursorPar: cursor: " << cursor() << endl; + return getPar(cursor().par()); } -ParagraphList::iterator LyXText::getPar(LyXCursor const & cur) const +ParagraphList::iterator LyXText::getPar(CursorSlice const & cur) const { return getPar(cur.par()); } @@ -1638,32 +1466,37 @@ ParagraphList::iterator LyXText::getPar(LyXCursor const & cur) const ParagraphList::iterator LyXText::getPar(int par) const { + //lyxerr << "getPar: " << par << " from " << paragraphs().size() << endl; BOOST_ASSERT(par >= 0); - BOOST_ASSERT(par < int(ownerParagraphs().size())); - ParagraphList::iterator pit = ownerParagraphs().begin(); - std::advance(pit, par); + BOOST_ASSERT(par < int(paragraphs().size())); + ParagraphList::iterator pit = paragraphs().begin(); + advance(pit, par); return pit; } +// y is relative to this LyXText's top RowList::iterator LyXText::getRowNearY(int y, ParagraphList::iterator & pit) const { - //lyxerr << "getRowNearY: y " << y << endl; -#if 0 - ParagraphList::iterator const pend = ownerParagraphs().end(); - pit = ownerParagraphs().begin(); + BOOST_ASSERT(!paragraphs().empty()); + BOOST_ASSERT(!paragraphs().begin()->rows.empty()); +#if 1 + ParagraphList::iterator const + pend = boost::prior(paragraphs().end()); + pit = paragraphs().begin(); while (int(pit->y + pit->height) < y && pit != pend) ++pit; - RowList::iterator rit = pit->rows.begin(); - RowList::iterator const rend = pit->rows.end(); - while (int(pit->y + rit->y_offset()) < y && rit != rend) - ++rit; - return rit; + RowList::iterator rit = pit->rows.end(); + RowList::iterator const rbegin = pit->rows.begin(); + do { + --rit; + } while (rit != rbegin && int(pit->y + rit->y_offset()) > y); + return rit; #else - pit = boost::prior(ownerParagraphs().end()); + pit = boost::prior(paragraphs().end()); RowList::iterator rit = lastRow(); RowList::iterator rbegin = firstRow(); @@ -1684,7 +1517,7 @@ int LyXText::getDepth() const RowList::iterator LyXText::firstRow() const { - return ownerParagraphs().front().rows.begin(); + return paragraphs().front().rows.begin(); } @@ -1696,7 +1529,7 @@ RowList::iterator LyXText::lastRow() const RowList::iterator LyXText::endRow() const { - return ownerParagraphs().back().rows.end(); + return paragraphs().back().rows.end(); } @@ -1706,7 +1539,7 @@ void LyXText::nextRow(ParagraphList::iterator & pit, ++rit; if (rit == pit->rows.end()) { ++pit; - if (pit == ownerParagraphs().end()) + if (pit == paragraphs().end()) --pit; else rit = pit->rows.begin(); @@ -1720,46 +1553,16 @@ void LyXText::previousRow(ParagraphList::iterator & pit, if (rit != pit->rows.begin()) --rit; else { - BOOST_ASSERT(pit != ownerParagraphs().begin()); + BOOST_ASSERT(pit != paragraphs().begin()); --pit; rit = boost::prior(pit->rows.end()); } } -string LyXText::selectionAsString(Buffer const & buffer, bool label) const -{ - if (!selection.set()) - return string(); - - // should be const ... - ParagraphList::iterator startpit = getPar(selection.start); - ParagraphList::iterator endpit = getPar(selection.end); - size_t const startpos = selection.start.pos(); - size_t const endpos = selection.end.pos(); - - if (startpit == endpit) - return startpit->asString(buffer, startpos, endpos, label); - - // First paragraph in selection - string result = - startpit->asString(buffer, startpos, startpit->size(), label) + "\n\n"; - - // The paragraphs in between (if any) - ParagraphList::iterator pit = startpit; - for (++pit; pit != endpit; ++pit) - result += pit->asString(buffer, 0, pit->size(), label) + "\n\n"; - - // Last paragraph in selection - result += endpit->asString(buffer, 0, endpos, label); - - return result; -} - - int LyXText::parOffset(ParagraphList::iterator pit) const { - return std::distance(ownerParagraphs().begin(), pit); + return distance(paragraphs().begin(), pit); } @@ -1778,24 +1581,25 @@ void LyXText::redoParagraphInternal(ParagraphList::iterator pit) InsetList::iterator iend = pit->insetlist.end(); for (; ii != iend; ++ii) { Dimension dim; - MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth()); + int const w = textWidth() - leftMargin(pit) - rightMargin(*pit); + MetricsInfo mi(bv(), getFont(pit, ii->pos), w); ii->inset->metrics(mi, dim); } // rebreak the paragraph - int const ww = workWidth(); + pit->setBeginOfBody(); pos_type z = 0; do { Row row(z); rowBreakPoint(pit, row); - z = row.endpos(); - fill(pit, row, ww); + setRowWidth(pit, row); prepareToPrint(pit, row); setHeightOfRow(pit, row); row.y_offset(pit->height); pit->rows.push_back(row); pit->width = std::max(pit->width, row.width()); pit->height += row.height(); + z = row.endpos(); } while (z < pit->size()); height += pit->height; @@ -1808,51 +1612,458 @@ void LyXText::redoParagraphs(ParagraphList::iterator pit, { for ( ; pit != end; ++pit) redoParagraphInternal(pit); - updateRowPositions(); + updateParPositions(); } void LyXText::redoParagraph(ParagraphList::iterator pit) { redoParagraphInternal(pit); - updateRowPositions(); + updateParPositions(); } void LyXText::fullRebreak() { - redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end()); - redoCursor(); - selection.cursor = cursor; + redoParagraphs(paragraphs().begin(), paragraphs().end()); + bv()->cursor().resetAnchor(); } void LyXText::metrics(MetricsInfo & mi, Dimension & dim) { - //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth - // << " workWidth: " << workWidth() << "\nfont: " << mi.base.font << endl; //BOOST_ASSERT(mi.base.textwidth); + if (mi.base.textwidth) + textwidth_ = mi.base.textwidth; + //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth + // << " textWidth: " << textWidth() << "\nfont: " << mi.base.font << endl; - // rebuild row cache. This recomputes height as well. - redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end()); + // Rebuild row cache. This recomputes height as well. + redoParagraphs(paragraphs().begin(), paragraphs().end()); - width = maxParagraphWidth(ownerParagraphs()); + width = maxParagraphWidth(paragraphs()); // final dimension dim.asc = firstRow()->ascent_of_text(); dim.des = height - dim.asc; - dim.wid = std::max(mi.base.textwidth, int(width)); + dim.wid = width; +} + + +// only used for inset right now. should also be used for main text +void LyXText::draw(PainterInfo & pi, int x, int y) const +{ + xo_ = x; + yo_ = y; + paintTextInset(*this, pi, x, y); +} + + +// only used for inset right now. should also be used for main text +void LyXText::drawSelection(PainterInfo &, int, int) const +{ + //lyxerr << "LyXText::drawSelection at " << x << " " << y << endl; } bool LyXText::isLastRow(ParagraphList::iterator pit, Row const & row) const { return row.endpos() >= pit->size() - && boost::next(pit) == ownerParagraphs().end(); + && boost::next(pit) == paragraphs().end(); } bool LyXText::isFirstRow(ParagraphList::iterator pit, Row const & row) const { - return row.pos() == 0 && pit == ownerParagraphs().begin(); + return row.pos() == 0 && pit == paragraphs().begin(); +} + + +void LyXText::getWord(CursorSlice & from, CursorSlice & to, + word_location const loc) +{ + Paragraph & from_par = *getPar(from); + switch (loc) { + case lyx::WHOLE_WORD_STRICT: + if (from.pos() == 0 || from.pos() == from_par.size() + || from_par.isSeparator(from.pos()) + || from_par.isKomma(from.pos()) + || from_par.isNewline(from.pos()) + || from_par.isSeparator(from.pos() - 1) + || from_par.isKomma(from.pos() - 1) + || from_par.isNewline(from.pos() - 1)) { + to = from; + return; + } + // no break here, we go to the next + + case lyx::WHOLE_WORD: + // Move cursor to the beginning, when not already there. + if (from.pos() && !from_par.isSeparator(from.pos() - 1) + && !(from_par.isKomma(from.pos() - 1) + || from_par.isNewline(from.pos() - 1))) + cursorLeftOneWord(bv()->cursor()); + break; + case lyx::PREVIOUS_WORD: + // always move the cursor to the beginning of previous word + cursorLeftOneWord(bv()->cursor()); + break; + case lyx::NEXT_WORD: + lyxerr << "LyXText::getWord: NEXT_WORD not implemented yet" + << endl; + break; + case lyx::PARTIAL_WORD: + break; + } + to = from; + Paragraph & to_par = *getPar(to); + while (to.pos() < to_par.size() + && !to_par.isSeparator(to.pos()) + && !to_par.isKomma(to.pos()) + && !to_par.isNewline(to.pos()) + && !to_par.isHfill(to.pos()) + && !to_par.isInset(to.pos())) + { + ++to.pos(); + } +} + + +void LyXText::write(Buffer const & buf, std::ostream & os) const +{ + ParagraphList::const_iterator pit = paragraphs().begin(); + ParagraphList::const_iterator end = paragraphs().end(); + Paragraph::depth_type dth = 0; + for (; pit != end; ++pit) + pit->write(buf, os, buf.params(), dth); +} + + +bool LyXText::read(Buffer const & buf, LyXLex & lex) +{ + static Change current_change; + + bool the_end_read = false; + ParagraphList::iterator pit = paragraphs().begin(); + Paragraph::depth_type depth = 0; + + while (lex.isOK()) { + lex.nextToken(); + string token = lex.getString(); + + if (token.empty()) + continue; + + if (in_inset_) { + + if (token == "\\end_inset") { + the_end_read = true; + break; + } + + if (token == "\\end_document") { + lex.printError("\\end_document read in inset! Error in document!"); + return false; + } + + } else { + + if (token == "\\end_document") { + the_end_read = true; + continue; + } + + } + + // FIXME: ugly. + int unknown = 0; + + if (token == "\\begin_layout") { + lex.pushToken(token); + + Paragraph par; + par.params().depth(depth); + if (buf.params().tracking_changes) + par.trackChanges(); + LyXFont f(LyXFont::ALL_INHERIT, buf.params().language); + par.setFont(0, f); + + // insert after + if (pit != paragraphs().end()) + ++pit; + + pit = paragraphs().insert(pit, par); + + // FIXME: goddamn InsetTabular makes us pass a Buffer + // not BufferParams + ::readParagraph(buf, *pit, lex); + + } else if (token == "\\begin_deeper") { + ++depth; + } else if (token == "\\end_deeper") { + if (!depth) { + lex.printError("\\end_deeper: " "depth is already null"); + } else { + --depth; + } + } else { + ++unknown; + } + + } + return the_end_read; +} + + +int LyXText::ascent() const +{ + return firstRow()->ascent_of_text(); +} + + +int LyXText::descent() const +{ + return height - firstRow()->ascent_of_text(); +} + + +int LyXText::cursorX(CursorSlice const & cur) const +{ + ParagraphList::iterator pit = getPar(cur); + if (pit->rows.empty()) + return xo_; + Row const & row = *pit->getRow(cur.pos()); + pos_type pos = cur.pos(); + pos_type cursor_vpos = 0; + double x = row.x(); + double fill_separator = row.fill_separator(); + double fill_hfill = row.fill_hfill(); + double fill_label_hfill = row.fill_label_hfill(); + pos_type const row_pos = row.pos(); + pos_type const end = row.endpos(); + + if (end <= row_pos) + cursor_vpos = row_pos; + else if (pos >= end) + cursor_vpos = isRTL(*pit) ? row_pos : end; + else if (pos > row_pos && pos >= end) + // Place cursor after char at (logical) position pos - 1 + cursor_vpos = (bidi.level(pos - 1) % 2 == 0) + ? bidi.log2vis(pos - 1) + 1 : bidi.log2vis(pos - 1); + else + // Place cursor before char at (logical) position pos + cursor_vpos = (bidi.level(pos) % 2 == 0) + ? bidi.log2vis(pos) : bidi.log2vis(pos) + 1; + + pos_type body_pos = pit->beginOfBody(); + if (body_pos > 0 && + (body_pos > end || !pit->isLineSeparator(body_pos - 1))) + body_pos = 0; + + for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) { + pos_type pos = bidi.vis2log(vpos); + if (body_pos > 0 && pos == body_pos - 1) { + x += fill_label_hfill + + font_metrics::width(pit->layout()->labelsep, + getLabelFont(pit)); + if (pit->isLineSeparator(body_pos - 1)) + x -= singleWidth(pit, body_pos - 1); + } + + if (hfillExpansion(*pit, row, pos)) { + x += singleWidth(pit, pos); + if (pos >= body_pos) + x += fill_hfill; + else + x += fill_label_hfill; + } else if (pit->isSeparator(pos)) { + x += singleWidth(pit, pos); + if (pos >= body_pos) + x += fill_separator; + } else + x += singleWidth(pit, pos); + } + return xo_ + int(x); +} + + +int LyXText::cursorY(CursorSlice const & cur) const +{ + Paragraph & par = *getPar(cur); + Row & row = *par.getRow(cur.pos()); + return yo_ + par.y + row.y_offset() + row.baseline(); +} + + +CursorSlice & LyXText::cursor() +{ + //lyxerr << "# accessing slice " << findText(this) << endl; + if (this != bv()->cursor().text()) { + lyxerr << "cursor: " << bv()->cursor() + << "\ntext: " << bv()->cursor().text() + << "\nthis: " << this << endl; + BOOST_ASSERT(false); + } + return bv()->cursor().current(); +} + + +CursorSlice const & LyXText::cursor() const +{ + if (this != bv()->cursor().text()) { + lyxerr << "cursor: " << bv()->cursor() + << "\ntext: " << bv()->cursor().text() + << "\nthis: " << this << endl; + BOOST_ASSERT(false); + } + return bv()->cursor().current(); +} + + +void LyXText::replaceSelection(LCursor & cur) +{ + BOOST_ASSERT(this == cur.text()); + if (cur.selection()) { + cutSelection(cur, true, false); + cur.update(); + } +} + + +// Returns the current font and depth as a message. +string LyXText::currentState(LCursor & cur) +{ + BOOST_ASSERT(this == cur.text()); + Buffer * buffer = bv()->buffer(); + Paragraph const & par = cur.paragraph(); + std::ostringstream os; + + bool const show_change = buffer->params().tracking_changes + && cur.pos() != cur.lastpos() + && par.lookupChange(cur.pos()) != Change::UNCHANGED; + + if (show_change) { + Change change = par.lookupChangeFull(cur.pos()); + Author const & a = buffer->params().authors().get(change.author); + os << _("Change: ") << a.name(); + if (!a.email().empty()) + os << " (" << a.email() << ")"; + if (change.changetime) + os << _(" at ") << ctime(&change.changetime); + os << " : "; + } + + // I think we should only show changes from the default + // font. (Asger) + LyXFont font = real_current_font; + font.reduce(buffer->params().getLyXTextClass().defaultfont()); + + // avoid _(...) re-entrance problem + string const s = font.stateText(&buffer->params()); + os << bformat(_("Font: %1$s"), s); + + // os << bformat(_("Font: %1$s"), font.stateText(&buffer->params)); + + // The paragraph depth + int depth = getDepth(); + if (depth > 0) + os << bformat(_(", Depth: %1$s"), tostr(depth)); + + // The paragraph spacing, but only if different from + // buffer spacing. + Spacing const & spacing = par.params().spacing(); + if (!spacing.isDefault()) { + os << _(", Spacing: "); + switch (spacing.getSpace()) { + case Spacing::Single: + os << _("Single"); + break; + case Spacing::Onehalf: + os << _("OneHalf"); + break; + case Spacing::Double: + os << _("Double"); + break; + case Spacing::Other: + os << _("Other (") << spacing.getValue() << ')'; + break; + case Spacing::Default: + // should never happen, do nothing + break; + } + } +#ifdef DEVEL_VERSION + os << _(", Paragraph: ") << par.id(); + os << _(", Position: ") << cur.pos(); + Row & row = cur.textRow(); + os << bformat(_(", Row b:%1$d e:%2$d"), row.pos(), row.endpos()); + os << _(", Inset: "); + InsetOld * inset = par.inInset(); + if (inset) + os << inset << " owner: " << inset->owner(); + else + os << -1; +#endif + return os.str(); +} + + +string LyXText::getPossibleLabel(LCursor & cur) const +{ + ParagraphList & plist = paragraphs(); + ParagraphList::iterator pit = getPar(cur.par()); + + LyXLayout_ptr layout = pit->layout(); + + if (layout->latextype == LATEX_PARAGRAPH && pit != plist.begin()) { + ParagraphList::iterator pit2 = boost::prior(pit); + + LyXLayout_ptr const & layout2 = pit2->layout(); + + if (layout2->latextype != LATEX_PARAGRAPH) { + pit = pit2; + layout = layout2; + } + } + + string text = layout->latexname().substr(0, 3); + if (layout->latexname() == "theorem") + text = "thm"; // Create a correct prefix for prettyref + + text += ':'; + if (layout->latextype == LATEX_PARAGRAPH || lyxrc.label_init_length < 0) + text.erase(); + + string par_text = pit->asString(*cur.bv().buffer(), false); + for (int i = 0; i < lyxrc.label_init_length; ++i) { + if (par_text.empty()) + break; + string head; + par_text = split(par_text, head, ' '); + // Is it legal to use spaces in labels ? + if (i > 0) + text += '-'; + text += head; + } + + return text; +} + + +int LyXText::dist(int x, int y) const +{ + int xx = 0; + int yy = 0; + + if (x < xo_) + xx = xo_ - x; + else if (x > xo_ + width) + xx = x - xo_ - width; + + if (y < yo_ - ascent()) + yy = yo_ - ascent() - y; + else if (y > yo_ + descent()) + yy = y - yo_ - descent(); + + return xx + yy; }