X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=0017e1ae149576b29cdc42ccf9475156691dc127;hb=acc5af9912533261c37795971af269f77317f14f;hp=88952f8dd16a6736a18cd21b9f6f1f1edc3c139b;hpb=e990b98cfdfb8cff4746f4cf8bd4ba2a8f08ef95;p=lyx.git diff --git a/src/Cursor.cpp b/src/Cursor.cpp index 88952f8dd1..0017e1ae14 100644 --- a/src/Cursor.cpp +++ b/src/Cursor.cpp @@ -26,9 +26,9 @@ #include "FuncCode.h" #include "FuncRequest.h" #include "Language.h" +#include "LyXAction.h" #include "LyXFunc.h" // only for setMessage() #include "LyXRC.h" -#include "paragraph_funcs.h" #include "Paragraph.h" #include "ParIterator.h" #include "Row.h" @@ -246,16 +246,6 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up) return true; } -docstring parbreak(Paragraph const & par) -{ - odocstringstream os; - os << '\n'; - // only add blank line if we're not in an ERT or Listings inset - if (par.ownerCode() != ERT_CODE && par.ownerCode() != LISTINGS_CODE) - os << '\n'; - return os.str(); -} - } // namespace anon @@ -264,16 +254,16 @@ docstring parbreak(Paragraph const & par) Cursor::Cursor(BufferView & bv) : DocIterator(&bv.buffer()), bv_(&bv), anchor_(), x_target_(-1), textTargetOffset_(0), - selection_(false), mark_(false), logicalpos_(false), - current_font(inherit_font) + selection_(false), mark_(false), word_selection_(false), + logicalpos_(false), current_font(inherit_font) {} -void Cursor::reset(Inset & inset) +void Cursor::reset() { clear(); - push_back(CursorSlice(inset)); - anchor_ = doc_iterator_begin(&inset.buffer(), &inset); + push_back(CursorSlice(buffer()->inset())); + anchor_ = doc_iterator_begin(buffer()); anchor_.clear(); clearTargetX(); selection_ = false; @@ -288,6 +278,43 @@ void Cursor::setCursor(DocIterator const & cur) } +bool Cursor::getStatus(FuncRequest const & cmd, FuncStatus & status) const +{ + Cursor cur = *this; + + // Try to fix cursor in case it is broken. + cur.fixIfBroken(); + + // Is this a function that acts on inset at point? + Inset * inset = cur.nextInset(); + if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint) + && inset && inset->getStatus(cur, cmd, status)) + return true; + + // This is, of course, a mess. Better create a new doc iterator and use + // this in Inset::getStatus. This might require an additional + // BufferView * arg, though (which should be avoided) + //Cursor safe = *this; + bool res = false; + for ( ; cur.depth(); cur.pop()) { + //lyxerr << "\nCursor::getStatus: cmd: " << cmd << endl << *this << endl; + LASSERT(cur.idx() <= cur.lastidx(), /**/); + LASSERT(cur.pit() <= cur.lastpit(), /**/); + LASSERT(cur.pos() <= cur.lastpos(), /**/); + + // The inset's getStatus() will return 'true' if it made + // a definitive decision on whether it want to handle the + // request or not. The result of this decision is put into + // the 'status' parameter. + if (cur.inset().getStatus(cur, cmd, status)) { + res = true; + break; + } + } + return res; +} + + void Cursor::dispatch(FuncRequest const & cmd0) { LYXERR(Debug::DEBUG, "cmd: " << cmd0 << '\n' << *this); @@ -297,7 +324,22 @@ void Cursor::dispatch(FuncRequest const & cmd0) fixIfBroken(); FuncRequest cmd = cmd0; Cursor safe = *this; + + buffer()->undo().beginUndoGroup(); + // Is this a function that acts on inset at point? + if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint) + && nextInset()) { + result().dispatched(true); + result().update(Update::FitCursor | Update::Force); + FuncRequest tmpcmd = cmd; + LYXERR(Debug::DEBUG, "Cursor::dispatch: (AtPoint) cmd: " + << cmd0 << endl << *this); + nextInset()->dispatch(*this, tmpcmd); + if (result().dispatched()) + return; + } + // store some values to be used inside of the handlers beforeDispatchCursor_ = *this; for (; depth(); pop(), boundary(false)) { @@ -321,6 +363,15 @@ void Cursor::dispatch(FuncRequest const & cmd0) // object will be used again. if (!disp_.dispatched()) { LYXERR(Debug::DEBUG, "RESTORING OLD CURSOR!"); + // We might have invalidated the cursor when removing an empty + // paragraph while the cursor could not be moved out the inset + // while we initially thought we could. This might happen when + // a multiline inset becomes an inline inset when the second + // paragraph is removed. + if (safe.pit() > safe.lastpit()) { + safe.pit() = safe.lastpit(); + safe.pos() = safe.lastpos(); + } operator=(safe); disp_.update(Update::None); disp_.dispatched(false); @@ -329,6 +380,7 @@ void Cursor::dispatch(FuncRequest const & cmd0) // are possible which would change it beforeDispatchCursor_ = safe.beforeDispatchCursor_; } + buffer()->undo().endUndoGroup(); } @@ -396,7 +448,10 @@ int Cursor::currentMode() LASSERT(!empty(), /**/); for (int i = depth() - 1; i >= 0; --i) { int res = operator[](i).inset().currentMode(); - if (res != Inset::UNDECIDED_MODE) + bool locked_mode = operator[](i).inset().lockedMode(); + // Also return UNDECIDED_MODE when the mode is locked, + // as in this case it is treated the same as TEXT_MODE + if (res != Inset::UNDECIDED_MODE || locked_mode) return res; } return Inset::TEXT_MODE; @@ -426,6 +481,18 @@ void Cursor::resetAnchor() } +void Cursor::setCursorToAnchor() +{ + if (selection()) { + DocIterator normal = anchor_; + while (depth() < normal.depth()) + normal.pop_back(); + if (depth() < anchor_.depth() && top() <= anchor_[depth() - 1]) + ++normal.pos(); + setCursor(normal); + } +} + bool Cursor::posBackward() { @@ -644,7 +711,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // The cursor is painted *before* the character at pos(), or, if 'boundary' // is true, *after* the character at (pos() - 1). So we already have one // known position around the cursor: - pos_type known_pos = boundary() ? pos() - 1 : pos(); + pos_type const known_pos = boundary() && pos() > 0 ? pos() - 1 : pos(); // edge case: if we're at the end of the paragraph, things are a little // different (because lastpos is a position which does not really "exist" @@ -653,8 +720,8 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) if (par.isRTL(buf.params())) { left_pos = -1; right_pos = bidi.vis2log(row.pos()); - } - else { // LTR paragraph + } else { + // LTR paragraph right_pos = -1; left_pos = bidi.vis2log(row.endpos() - 1); } @@ -669,11 +736,10 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // For an RTL character, "before" means "to the right" and "after" means // "to the left"; and for LTR, it's the reverse. So, 'known_pos' is to the // right of the cursor if (RTL && boundary) or (!RTL && !boundary): - bool known_pos_on_right = (cur_is_RTL == boundary()); + bool const known_pos_on_right = cur_is_RTL == boundary(); // So we now know one of the positions surrounding the cursor. Let's - // determine the other one: - + // determine the other one: if (known_pos_on_right) { right_pos = known_pos; // *visual* position of 'left_pos': @@ -687,9 +753,9 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) if (bidi.inRange(v_left_pos) && bidi.vis2log(v_left_pos) + 1 == row.endpos() && row.endpos() < lastpos() - && par.isSeparator(bidi.vis2log(v_left_pos))) { + && par.isSeparator(bidi.vis2log(v_left_pos))) --v_left_pos; - } + // calculate the logical position of 'left_pos', if in row if (!bidi.inRange(v_left_pos)) left_pos = -1; @@ -699,14 +765,14 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // separator", set 'right_pos' to the *next* position to the right. if (right_pos + 1 == row.endpos() && row.endpos() < lastpos() && par.isSeparator(right_pos)) { - pos_type v_right_pos = bidi.log2vis(right_pos) + 1; + pos_type const v_right_pos = bidi.log2vis(right_pos) + 1; if (!bidi.inRange(v_right_pos)) right_pos = -1; else right_pos = bidi.vis2log(v_right_pos); } - } - else { // known_pos is on the left + } else { + // known_pos is on the left left_pos = known_pos; // *visual* position of 'right_pos' pos_type v_right_pos = bidi.log2vis(left_pos) + 1; @@ -715,9 +781,9 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) if (bidi.inRange(v_right_pos) && bidi.vis2log(v_right_pos) + 1 == row.endpos() && row.endpos() < lastpos() - && par.isSeparator(bidi.vis2log(v_right_pos))) { + && par.isSeparator(bidi.vis2log(v_right_pos))) ++v_right_pos; - } + // calculate the logical position of 'right_pos', if in row if (!bidi.inRange(v_right_pos)) right_pos = -1; @@ -727,7 +793,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // separator", set 'left_pos' to the *next* position to the left. if (left_pos + 1 == row.endpos() && row.endpos() < lastpos() && par.isSeparator(left_pos)) { - pos_type v_left_pos = bidi.log2vis(left_pos) - 1; + pos_type const v_left_pos = bidi.log2vis(left_pos) - 1; if (!bidi.inRange(v_left_pos)) left_pos = -1; else @@ -889,7 +955,7 @@ void Cursor::posVisToRowExtremity(bool left) // as explained above, if at last pos in row, stay to the left, // unless the last position is the same as the first. bool const left_of_pos = row.endpos() > 0 - && pos() == row.endpos() - 1 && !par.isInset(pos())); + && pos() == row.endpos() - 1 && !par.isInset(pos()); // Now we know if we want to be to the left or to the right of pos, // let's make sure we are where we want to be. @@ -909,6 +975,8 @@ void Cursor::posVisToRowExtremity(bool left) CursorSlice Cursor::anchor() const { + if (!selection()) + return top(); LASSERT(anchor_.depth() >= depth(), /**/); CursorSlice normal = anchor_[depth() - 1]; if (depth() < anchor_.depth() && top() <= normal) { @@ -997,6 +1065,7 @@ void Cursor::setSelection(DocIterator const & where, int n) void Cursor::clearSelection() { setSelection(false); + setWordSelection(false); setMark(false); resetAnchor(); } @@ -1237,11 +1306,11 @@ void Cursor::insert(Inset * inset0) } -void Cursor::niceInsert(docstring const & t, Parse::flags f) +void Cursor::niceInsert(docstring const & t, Parse::flags f, bool enter) { - MathData ar; + MathData ar(buffer()); asArray(t, ar, f); - if (ar.size() == 1) + if (ar.size() == 1 && (enter || selection())) niceInsert(ar[0]); else insert(ar); @@ -1253,14 +1322,14 @@ void Cursor::niceInsert(MathAtom const & t) macroModeClose(); docstring const safe = cap::grabAndEraseSelection(*this); plainInsert(t); - // enter the new inset and move the contents of the selection if possible + // If possible, enter the new inset and move the contents of the selection if (t->isActive()) { posBackward(); // be careful here: don't use 'pushBackward(t)' as this we need to // push the clone, not the original pushBackward(*nextInset()); // We may not use niceInsert here (recursion) - MathData ar; + MathData ar(buffer()); asArray(safe, ar); insert(ar); } @@ -1411,7 +1480,7 @@ bool Cursor::macroModeClose() return false; InsetMathUnknown * p = activeMacro(); p->finalize(); - MathData selection; + MathData selection(buffer()); asArray(p->selection(), selection); docstring const s = p->name(); --pos(); @@ -1429,7 +1498,8 @@ bool Cursor::macroModeClose() InsetMathNest * const in = inset().asInsetMath()->asNestInset(); if (in && in->interpretString(*this, s)) return true; - MathAtom atom = createInsetMath(name); + MathAtom atom = buffer()->getMacro(name, *this, false) ? + MathAtom(new MathMacro(buffer(), name)) : createInsetMath(name, buffer()); // try to put argument into macro, if we just inserted a macro bool macroArg = false; @@ -1455,7 +1525,7 @@ bool Cursor::macroModeClose() // finally put the macro argument behind, if needed if (macroArg) { - if (selection.size() > 1) + if (selection.size() > 1 || selection[0]->asScriptInset()) plainInsert(MathAtom(new InsetMathBrace(selection))); else insert(selection); @@ -1571,7 +1641,7 @@ void Cursor::normalize() << pos() << ' ' << lastpos() << " in idx: " << idx() << " in atom: '"; odocstringstream os; - WriteStream wi(os, false, true, false); + WriteStream wi(os, false, true, WriteStream::wsDefault); inset().asInsetMath()->write(wi); lyxerr << to_utf8(os.str()) << endl; pos() = lastpos(); @@ -1770,8 +1840,34 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) else row = pm.pos2row(pos()); - if (atFirstOrLastRow(up)) + if (atFirstOrLastRow(up)) { + // Is there a place for the cursor to go ? If yes, we + // can execute the DEPM, otherwise we should keep the + // paragraph to host the cursor. + Cursor dummy = *this; + bool valid_destination = false; + for(; dummy.depth(); dummy.pop()) + if (!dummy.atFirstOrLastRow(up)) { + valid_destination = true; + break; + } + + // will a next dispatch follow and if there is a new + // dispatch will it move the cursor out ? + if (depth() > 1 && valid_destination) { + // The cursor hasn't changed yet. This happens when + // you e.g. move out of an inset. And to give the + // DEPM the possibility of doing something we must + // provide it with two different cursors. (Lgb, vfr) + dummy = *this; + dummy.pos() = dummy.pos() == 0 ? dummy.lastpos() : 0; + dummy.pit() = dummy.pit() == 0 ? dummy.lastpit() : 0; + + updateNeeded |= bv().checkDepm(dummy, *this); + updateTextTargetOffset(); + } return false; + } // with and without selection are handled differently if (!selection()) { @@ -1784,43 +1880,56 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) tm.editXY(*this, xo, yo + textRow().descent() + 1); clearSelection(); - // This happens when you move out of an inset. - // And to give the DEPM the possibility of doing - // something we must provide it with two different - // cursors. (Lgb) + // This happens when you move out of an inset. + // And to give the DEPM the possibility of doing + // something we must provide it with two different + // cursors. (Lgb) Cursor dummy = *this; if (dummy == old) ++dummy.pos(); if (bv().checkDepm(dummy, old)) { updateNeeded = true; - // Make sure that cur gets back whatever happened to dummy(Lgb) + // Make sure that cur gets back whatever happened to dummy(Lgb) operator=(dummy); } } else { - // if there is a selection, we stay out of any inset, and just jump to the right position: + // if there is a selection, we stay out of any inset, + // and just jump to the right position: Cursor old = *this; + int next_row = row; if (up) { if (row > 0) { - top().pos() = min(tm.x2pos(pit(), row - 1, xo), top().lastpos()); + --next_row; } else if (pit() > 0) { --pit(); TextMetrics & tm = bv_->textMetrics(text()); if (!tm.contains(pit())) tm.newParMetricsUp(); ParagraphMetrics const & pmcur = tm.parMetrics(pit()); - top().pos() = min(tm.x2pos(pit(), pmcur.rows().size() - 1, xo), top().lastpos()); + next_row = pmcur.rows().size() - 1; } } else { if (row + 1 < int(pm.rows().size())) { - top().pos() = min(tm.x2pos(pit(), row + 1, xo), top().lastpos()); + ++next_row; } else if (pit() + 1 < int(text()->paragraphs().size())) { ++pit(); TextMetrics & tm = bv_->textMetrics(text()); if (!tm.contains(pit())) tm.newParMetricsDown(); - top().pos() = min(tm.x2pos(pit(), 0, xo), top().lastpos()); + next_row = 0; } } + top().pos() = min(tm.x2pos(pit(), next_row, xo), top().lastpos()); + + int const xpos = tm.x2pos(pit(), next_row, xo); + bool const at_end_row = xpos == tm.x2pos(pit(), next_row, tm.width()); + bool const at_beg_row = xpos == tm.x2pos(pit(), next_row, 0); + + if (at_end_row && at_beg_row) + // make sure the cursor ends up on this row + boundary(false); + else + boundary(at_end_row); updateNeeded |= bv().checkDepm(*this, old); } @@ -1852,8 +1961,8 @@ void Cursor::handleFont(string const & font) } else { // cursor in between. split cell MathData::iterator bt = cell().begin(); - MathAtom at = createInsetMath(from_utf8(font)); - at.nucleus()->cell(0) = MathData(bt, bt + pos()); + MathAtom at = createInsetMath(from_utf8(font), buffer()); + at.nucleus()->cell(0) = MathData(buffer(), bt, bt + pos()); cell().erase(bt, bt + pos()); popBackward(); plainInsert(at); @@ -1880,56 +1989,63 @@ void Cursor::errorMessage(docstring const & msg) const } +static docstring parbreak(InsetCode code) +{ + odocstringstream os; + os << '\n'; + // only add blank line if we're not in an ERT or Listings inset + if (code != ERT_CODE && code != LISTINGS_CODE) + os << '\n'; + return os.str(); +} + + docstring Cursor::selectionAsString(bool with_label) const { if (!selection()) return docstring(); + if (inMathed()) + return cap::grabSelection(*this); + int const label = with_label ? AS_STR_LABEL | AS_STR_INSETS : AS_STR_INSETS; - if (inTexted()) { - idx_type const startidx = selBegin().idx(); - idx_type const endidx = selEnd().idx(); - if (startidx != endidx) { - // multicell selection - InsetTabular * table = inset().asInsetTabular(); - LASSERT(table, return docstring()); - return table->asString(startidx, endidx); - } - - ParagraphList const & pars = text()->paragraphs(); - - pit_type const startpit = selBegin().pit(); - pit_type const endpit = selEnd().pit(); - size_t const startpos = selBegin().pos(); - size_t const endpos = selEnd().pos(); - - if (startpit == endpit) - return pars[startpit].asString(startpos, endpos, label); - - // First paragraph in selection - docstring result = pars[startpit]. - asString(startpos, pars[startpit].size(), label) - + parbreak(pars[startpit]); - - // The paragraphs in between (if any) - for (pit_type pit = startpit + 1; pit != endpit; ++pit) { - Paragraph const & par = pars[pit]; - result += par.asString(0, par.size(), label) - + parbreak(pars[pit]); - } + idx_type const startidx = selBegin().idx(); + idx_type const endidx = selEnd().idx(); + if (startidx != endidx) { + // multicell selection + InsetTabular * table = inset().asInsetTabular(); + LASSERT(table, return docstring()); + return table->asString(startidx, endidx); + } + + ParagraphList const & pars = text()->paragraphs(); + + pit_type const startpit = selBegin().pit(); + pit_type const endpit = selEnd().pit(); + size_t const startpos = selBegin().pos(); + size_t const endpos = selEnd().pos(); + + if (startpit == endpit) + return pars[startpit].asString(startpos, endpos, label); - // Last paragraph in selection - result += pars[endpit].asString(0, endpos, label); + // First paragraph in selection + docstring result = pars[startpit]. + asString(startpos, pars[startpit].size(), label) + + parbreak(inset().lyxCode()); - return result; + // The paragraphs in between (if any) + for (pit_type pit = startpit + 1; pit != endpit; ++pit) { + Paragraph const & par = pars[pit]; + result += par.asString(0, par.size(), label) + + parbreak(inset().lyxCode()); } - if (inMathed()) - return cap::grabSelection(*this); + // Last paragraph in selection + result += pars[endpit].asString(0, endpos, label); - return docstring(); + return result; } @@ -1961,7 +2077,7 @@ Encoding const * Cursor::getEncoding() const CursorSlice const & sl = innerTextSlice(); Text const & text = *sl.text(); Font font = text.getPar(sl.pit()).getFont( - bv().buffer().params(), sl.pos(), outerFont(sl.pit(), text.paragraphs())); + bv().buffer().params(), sl.pos(), text.outerFont(sl.pit())); return font.language()->encoding(); } @@ -2018,7 +2134,7 @@ Font Cursor::getFont() const // get font at the position Font font = par.getFont(buffer()->params(), pos, - outerFont(sl.pit(), text.paragraphs())); + text.outerFont(sl.pit())); return font; } @@ -2048,15 +2164,15 @@ bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur) && !cur.buffer()->isClean() && cur.inTexted() && old.inTexted() && cur.pit() != old.pit()) { - old.paragraph().updateWords(old.top()); + old.paragraph().updateWords(); } // notify everything on top of the common part in old cursor, // but stop if the inset claims the cursor to be invalid now for (size_type j = i; j < old.depth(); ++j) { - Cursor insetPos = old; - insetPos.cutOff(j); - if (old[j].inset().notifyCursorLeaves(insetPos, cur)) + Cursor inset_pos = old; + inset_pos.cutOff(j); + if (old[j].inset().notifyCursorLeaves(inset_pos, cur)) return true; }