X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fcursor.C;h=e72426f64753af016508c789645b98736ca49466;hb=41ecabf5197a74719dd125e974b062184208c96b;hp=82bfc82d6a8842fd6d0b3dfe4d64a0867ff7aa6b;hpb=ba0a69bcd964c1962ddfb0ac01f92127da26171c;p=lyx.git diff --git a/src/cursor.C b/src/cursor.C index 82bfc82d6a..e72426f647 100644 --- a/src/cursor.C +++ b/src/cursor.C @@ -15,6 +15,7 @@ #include "BufferView.h" #include "buffer.h" #include "cursor.h" +#include "coordcache.h" #include "CutAndPaste.h" #include "debug.h" #include "dispatchresult.h" @@ -40,13 +41,18 @@ #include "mathed/math_macrotable.h" #include "support/limited_stack.h" -#include "support/std_sstream.h" #include "frontends/LyXView.h" +#include "frontends/font_metrics.h" #include +#include +#include -using lyx::par_type; +#include +#include + +using lyx::pit_type; using std::string; using std::vector; @@ -57,10 +63,109 @@ using std::isalpha; using std::min; using std::swap; +namespace { + + bool + positionable(DocIterator const & cursor, DocIterator const & anchor) + { + // avoid deeper nested insets when selecting + if (cursor.depth() > anchor.depth()) + return false; + + // anchor might be deeper, should have same path then + for (size_t i = 0; i < cursor.depth(); ++i) + if (&cursor[i].inset() != &anchor[i].inset()) + return false; + + // position should be ok. + return true; + } + + + // Find position closest to (x, y) in cell given by iter. + // Used only in mathed + DocIterator bruteFind2(LCursor const & c, int x, int y) + { + double best_dist = std::numeric_limits::max(); + + DocIterator result; + + DocIterator it = c; + it.top().pos() = 0; + DocIterator et = c; + et.top().pos() = et.top().asMathInset()->cell(et.top().idx()).size(); + for (int i = 0; ; ++i) { + int xo; + int yo; + it.inset().cursorPos(it.top(), c.boundary(), xo, yo); + double d = (x - xo) * (x - xo) + (y - yo) * (y - yo); + // '<=' in order to take the last possible position + // this is important for clicking behind \sum in e.g. '\sum_i a' + lyxerr[Debug::DEBUG] << "i: " << i << " d: " << d + << " best: " << best_dist << endl; + if (d <= best_dist) { + best_dist = d; + result = it; + } + if (it == et) + break; + it.forwardPos(); + } + return result; + } + + /// moves position closest to (x, y) in given box + bool bruteFind(LCursor & cursor, + int x, int y, int xlow, int xhigh, int ylow, int yhigh) + { + BOOST_ASSERT(!cursor.empty()); + CursorSlice bottom = cursor[0]; + + DocIterator it = doc_iterator_begin(bottom.inset()); + DocIterator const et = doc_iterator_end(bottom.inset()); + + double best_dist = std::numeric_limits::max();; + DocIterator best_cursor = et; + + for ( ; it != et; it.forwardPos()) { + // avoid invalid nesting when selecting + if (bv_funcs::status(&cursor.bv(), it) == bv_funcs::CUR_INSIDE + && (!cursor.selection() || positionable(it, cursor.anchor_))) { + Point p = bv_funcs::getPos(it, false); + int xo = p.x_; + int yo = p.y_; + if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) { + double d = (x - xo) * (x - xo) + (y - yo) * (y - yo); + //lyxerr << "xo: " << xo << " yo: " << yo << " d: " << d << endl; + // '<=' in order to take the last possible position + // this is important for clicking behind \sum in e.g. '\sum_i a' + if (d <= best_dist) { + //lyxerr << "*" << endl; + best_dist = d; + best_cursor = it; + } + } + } + } + + //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl; + if (best_cursor != et) { + cursor.setCursor(best_cursor); + return true; + } + + return false; + } + +} // namespace anon + + +// be careful: this is called from the bv's constructor, too, so +// bv functions are not yet available! LCursor::LCursor(BufferView & bv) : DocIterator(), bv_(&bv), anchor_(), x_target_(-1), - selection_(false), mark_(false) + selection_(false), mark_(false), logicalpos_(false) {} @@ -75,28 +180,31 @@ void LCursor::reset(InsetBase & inset) } -void LCursor::setCursor(DocIterator const & cur, bool sel) +// this (intentionally) does neither touch anchor nor selection status +void LCursor::setCursor(DocIterator const & cur) { - // this (intentionally) does not touch the anchor DocIterator::operator=(cur); - selection() = sel; } -DispatchResult LCursor::dispatch(FuncRequest const & cmd0) +void LCursor::dispatch(FuncRequest const & cmd0) { - lyxerr << "\nLCursor::dispatch: cmd: " << cmd0 << endl << *this << endl; + lyxerr[Debug::DEBUG] << BOOST_CURRENT_FUNCTION + << " cmd: " << cmd0 << '\n' + << *this << endl; if (empty()) - return DispatchResult(); + return; + fixIfBroken(); FuncRequest cmd = cmd0; LCursor safe = *this; - for ( ; size(); pop()) { - //lyxerr << "\nLCursor::dispatch: cmd: " << cmd0 << endl << *this << endl; + for (; depth(); pop()) { + lyxerr[Debug::DEBUG] << "LCursor::dispatch: cmd: " + << cmd0 << endl << *this << endl; BOOST_ASSERT(pos() <= lastpos()); BOOST_ASSERT(idx() <= lastidx()); - BOOST_ASSERT(par() <= lastpar()); + BOOST_ASSERT(pit() <= lastpit()); // The common case is 'LFUN handled, need update', so make the // LFUN handler's life easier by assuming this as default value. @@ -110,38 +218,16 @@ DispatchResult LCursor::dispatch(FuncRequest const & cmd0) // it completely to get a 'bomb early' behaviour in case this // object will be used again. if (!disp_.dispatched()) { - lyxerr << "RESTORING OLD CURSOR!" << endl; + lyxerr[Debug::DEBUG] << "RESTORING OLD CURSOR!" << endl; operator=(safe); disp_.dispatched(false); } - return disp_; } -bool LCursor::getStatus(FuncRequest const & cmd, FuncStatus & status) +DispatchResult LCursor::result() const { - // 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) - LCursor safe = *this; - bool res = false; - for ( ; size(); pop()) { - //lyxerr << "\nLCursor::getStatus: cmd: " << cmd << endl << *this << endl; - BOOST_ASSERT(pos() <= lastpos()); - BOOST_ASSERT(idx() <= lastidx()); - BOOST_ASSERT(par() <= lastpar()); - - // 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 (inset().getStatus(*this, cmd, status)) { - res = true; - break; - } - } - operator=(safe); - return res; + return disp_; } @@ -162,7 +248,7 @@ Buffer & LCursor::buffer() const void LCursor::pop() { - BOOST_ASSERT(size() >= 1); + BOOST_ASSERT(depth() >= 1); pop_back(); } @@ -210,7 +296,7 @@ bool LCursor::popRight() int LCursor::currentMode() { BOOST_ASSERT(!empty()); - for (int i = size() - 1; i >= 0; --i) { + for (int i = depth() - 1; i >= 0; --i) { int res = operator[](i).inset().currentMode(); if (res != InsetBase::UNDECIDED_MODE) return res; @@ -219,31 +305,11 @@ int LCursor::currentMode() } -void LCursor::getDim(int & asc, int & des) const -{ - if (inMathed()) { - BOOST_ASSERT(inset().asMathInset()); - //inset().asMathInset()->getCursorDim(asc, des); - asc = 10; - des = 10; - } else if (inTexted()) { - Row const & row = textRow(); - asc = row.baseline(); - des = row.height() - asc; - } else { - lyxerr << "should this happen?" << endl; - asc = 10; - des = 10; - } -} - - void LCursor::getPos(int & x, int & y) const { - x = 0; - y = 0; - if (!empty()) - inset().getCursorPos(*this, x, y); + Point p = bv_funcs::getPos(*this, boundary()); + x = p.x_; + y = p.y_; } @@ -280,9 +346,9 @@ bool LCursor::posRight() CursorSlice LCursor::anchor() const { - BOOST_ASSERT(anchor_.size() >= size()); - CursorSlice normal = anchor_[size() - 1]; - if (size() < anchor_.size() && back() <= normal) { + BOOST_ASSERT(anchor_.depth() >= depth()); + CursorSlice normal = anchor_[depth() - 1]; + if (depth() < anchor_.depth() && top() <= normal) { // anchor is behind cursor -> move anchor behind the inset ++normal.pos(); } @@ -293,16 +359,16 @@ CursorSlice LCursor::anchor() const CursorSlice LCursor::selBegin() const { if (!selection()) - return back(); - return anchor() < back() ? anchor() : back(); + return top(); + return anchor() < top() ? anchor() : top(); } CursorSlice LCursor::selEnd() const { if (!selection()) - return back(); - return anchor() > back() ? anchor() : back(); + return top(); + return anchor() > top() ? anchor() : top(); } @@ -310,7 +376,7 @@ DocIterator LCursor::selectionBegin() const { if (!selection()) return *this; - return anchor() < back() ? anchor_ : *this; + return anchor() < top() ? anchor_ : *this; } @@ -318,25 +384,31 @@ DocIterator LCursor::selectionEnd() const { if (!selection()) return *this; - return anchor() > back() ? anchor_ : *this; + return anchor() > top() ? anchor_ : *this; } void LCursor::setSelection() { selection() = true; - // a selection with no contents is not a selection + // A selection with no contents is not a selection +#ifdef WITH_WARNINGS #warning doesnt look ok - if (par() == anchor().par() && pos() == anchor().pos()) +#endif + if (pit() == anchor().pit() && pos() == anchor().pos()) selection() = false; } void LCursor::setSelection(DocIterator const & where, size_t n) { - setCursor(where, true); + setCursor(where); + selection() = true; anchor_ = where; pos() += n; + // Open all collapsed insets + for (int i = depth() - 1; i >= 0; --i) + operator[](i).inset().setStatus(*this, InsetBase::Open); } @@ -384,13 +456,9 @@ void LCursor::info(std::ostream & os) const void LCursor::selHandle(bool sel) { //lyxerr << "LCursor::selHandle" << endl; - if (sel == selection()) { -#warning Alfredo: This is too strong (Andre) - //if (!sel) - // noUpdate(); + if (sel == selection()) return; - } - + resetAnchor(); selection() = sel; } @@ -398,15 +466,16 @@ void LCursor::selHandle(bool sel) std::ostream & operator<<(std::ostream & os, LCursor const & cur) { - for (size_t i = 0, n = cur.size(); i != n; ++i) { - os << " " << cur.operator[](i) << " | "; - if (i < cur.anchor_.size()) + os << "\n cursor: | anchor:\n"; + for (size_t i = 0, n = cur.depth(); i != n; ++i) { + os << " " << cur[i] << " | "; + if (i < cur.anchor_.depth()) os << cur.anchor_[i]; else os << "-------------------------------"; os << "\n"; } - for (size_t i = cur.size(), n = cur.anchor_.size(); i < n; ++i) { + for (size_t i = cur.depth(), n = cur.anchor_.depth(); i < n; ++i) { os << "------------------------------- | " << cur.anchor_[i] << "\n"; } os << " selection: " << cur.selection_ @@ -439,13 +508,24 @@ std::ostream & operator<<(std::ostream & os, LCursor const & cur) bool LCursor::isInside(InsetBase const * p) { - for (unsigned i = 0; i < depth(); ++i) + for (size_t i = 0; i != depth(); ++i) if (&operator[](i).inset() == p) return true; return false; } +void LCursor::leaveInset(InsetBase const & inset) +{ + for (size_t i = 0; i != depth(); ++i) { + if (&operator[](i).inset() == &inset) { + resize(i); + return; + } + } +} + + bool LCursor::openable(MathAtom const & t) const { if (!t->isActive()) @@ -458,7 +538,7 @@ bool LCursor::openable(MathAtom const & t) const return true; // we can't move into anything new during selection - if (depth() >= anchor_.size()) + if (depth() >= anchor_.depth()) return false; if (!ptr_cmp(t.nucleus(), &anchor_[depth()].inset())) return false; @@ -467,27 +547,10 @@ bool LCursor::openable(MathAtom const & t) const } -bool positionable(DocIterator const & cursor, - DocIterator const & anchor) -{ - // avoid deeper nested insets when selecting - if (cursor.size() > anchor.size()) - return false; - - // anchor might be deeper, should have same path then - for (size_t i = 0; i < cursor.size(); ++i) - if (&cursor[i].inset() != &anchor[i].inset()) - return false; - - // position should be ok. - return true; -} - - void LCursor::setScreenPos(int x, int y) { x_target() = x; - bruteFind(x, y, 0, bv().workWidth(), 0, bv().workHeight()); + bruteFind(*this, x, y, 0, bv().workWidth(), 0, bv().workHeight()); } @@ -519,9 +582,9 @@ void LCursor::plainInsert(MathAtom const & t) void LCursor::insert(string const & str) { - //lyxerr << "LCursor::insert str '" << str << "'" << endl; - for (string::const_iterator it = str.begin(); it != str.end(); ++it) - insert(*it); + for_each(str.begin(), str.end(), + boost::bind(static_cast + (&LCursor::insert), this, _1)); } @@ -540,11 +603,10 @@ void LCursor::insert(char c) void LCursor::insert(MathAtom const & t) { - //lyxerr << "LCursor::insert MathAtom: " << endl; + //lyxerr << "LCursor::insert MathAtom '" << t << "'" << endl; macroModeClose(); lyx::cap::selClearOrDel(*this); plainInsert(t); - lyxerr << "LCursor::insert MathAtom: cur:\n" << *this << endl; } @@ -571,7 +633,7 @@ void LCursor::niceInsert(string const & t) void LCursor::niceInsert(MathAtom const & t) { macroModeClose(); - string safe = lyx::cap::grabAndEraseSelection(*this); + string const safe = lyx::cap::grabAndEraseSelection(*this); plainInsert(t); // enter the new inset and move the contents of the selection if possible if (t->isActive()) { @@ -679,7 +741,7 @@ bool LCursor::up() DocIterator save = *this; if (goUpDown(true)) return true; - setCursor(save, false); + setCursor(save); autocorrect() = false; return selection(); } @@ -691,7 +753,7 @@ bool LCursor::down() DocIterator save = *this; if (goUpDown(false)) return true; - setCursor(save, false); + setCursor(save); autocorrect() = false; return selection(); } @@ -703,7 +765,7 @@ void LCursor::macroModeClose() return; MathUnknownInset * p = activeMacro(); p->finalize(); - string s = p->name(); + string const s = p->name(); --pos(); cell().erase(pos()); @@ -714,11 +776,13 @@ void LCursor::macroModeClose() string const name = s.substr(1); // prevent entering of recursive macros + // FIXME: this is only a weak attempt... only prevents immediate + // recursion InsetBase const * macro = innerInsetOfType(InsetBase::MATHMACRO_CODE); if (macro && macro->getInsetName() == name) lyxerr << "can't enter recursive macro" << endl; - niceInsert(createMathInset(name)); + plainInsert(createMathInset(name)); } @@ -750,9 +814,21 @@ int LCursor::targetX() const } +void LCursor::setTargetX() +{ + // For now this is good enough. A better solution would be to + // avoid this rebreak by setting cursorX only after drawing + bottom().text()->redoParagraph(bottom().pit()); + int x; + int y; + getPos(x, y); + x_target_ = x; +} + + bool LCursor::inMacroMode() const { - if (!pos() != 0) + if (pos() == 0) return false; MathUnknownInset const * p = prevAtom()->asUnknownInset(); return p && !p->final(); @@ -823,7 +899,7 @@ bool LCursor::goUpDown(bool up) // matters. So fiddle around with it only if you think you know // what you are doing! - int xo = 0; + int xo = 0; int yo = 0; getPos(xo, yo); @@ -861,28 +937,24 @@ bool LCursor::goUpDown(bool up) } } - // try current cell for e.g. text insets - if (inset().idxUpDown2(*this, up)) - return true; - //xarray().boundingBox(xlow, xhigh, ylow, yhigh); //if (up) // yhigh = yo - 4; //else // ylow = yo + 4; - //if (bruteFind(xo, yo, xlow, xhigh, ylow, yhigh)) { + //if (bruteFind(*this, xo, yo, xlow, xhigh, ylow, yhigh)) { // lyxerr << "updown: handled by brute find in the same cell" << endl; // return true; //} // try to find an inset that knows better then we - while (1) { + while (true) { //lyxerr << "updown: We are in " << &inset() << " idx: " << idx() << endl; // ask inset first if (inset().idxUpDown(*this, up)) { // try to find best position within this inset if (!selection()) - bruteFind2(xo, yo); + setCursor(bruteFind2(*this, xo, yo)); return true; } @@ -891,98 +963,25 @@ bool LCursor::goUpDown(bool up) if (!popLeft()) { int ylow = up ? 0 : yo + 1; int yhigh = up ? yo - 1 : bv().workHeight(); - return bruteFind(xo, yo, 0, bv().workWidth(), ylow, yhigh); + return bruteFind(*this, xo, yo, 0, bv().workWidth(), ylow, yhigh); } // any improvement so far? - int xnew, ynew; + int xnew; + int ynew; getPos(xnew, ynew); if (up ? ynew < yo : ynew > yo) return true; } -} - -bool LCursor::bruteFind(int x, int y, int xlow, int xhigh, int ylow, int yhigh) -{ - BOOST_ASSERT(!empty()); - par_type beg, end; - CursorSlice bottom = operator[](0); - LyXText * text = bottom.text(); - BOOST_ASSERT(text); - getParsInRange(text->paragraphs(), ylow, yhigh, beg, end); - - DocIterator it = doc_iterator_begin(bv().buffer()->inset()); - DocIterator et = doc_iterator_end(bv().buffer()->inset()); - //lyxerr << "x: " << x << " y: " << y << endl; - //lyxerr << "xlow: " << xlow << " ylow: " << ylow << endl; - //lyxerr << "xhigh: " << xhigh << " yhigh: " << yhigh << endl; - - it.par() = beg; - //et.par() = text->parOffset(end); - - double best_dist = 10e10; - DocIterator best_cursor = it; - - for ( ; it != et; it.forwardPos()) { - // avoid invalid nesting when selecting - if (!selection() || positionable(it, anchor_)) { - int xo = 0, yo = 0; - LCursor cur = *this; - cur.setCursor(it, false); - cur.inset().getCursorPos(cur, xo, yo); - if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) { - double d = (x - xo) * (x - xo) + (y - yo) * (y - yo); - //lyxerr << "xo: " << xo << " yo: " << yo << " d: " << d << endl; - // '<=' in order to take the last possible position - // this is important for clicking behind \sum in e.g. '\sum_i a' - if (d <= best_dist) { - //lyxerr << "*" << endl; - best_dist = d; - best_cursor = it; - } - } - } - } - - //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl; - if (best_dist < 1e10) - setCursor(best_cursor, false); - return best_dist < 1e10; -} - - -void LCursor::bruteFind2(int x, int y) -{ - double best_dist = 1e10; - - DocIterator it = *this; - it.back().pos() = 0; - DocIterator et = *this; - et.back().pos() = et.back().asMathInset()->cell(et.back().idx()).size(); - for (int i = 0; ; ++i) { - int xo, yo; - LCursor cur = *this; - cur.setCursor(it, false); - cur.inset().getCursorPos(cur, xo, yo); - double d = (x - xo) * (x - xo) + (y - yo) * (y - yo); - // '<=' in order to take the last possible position - // this is important for clicking behind \sum in e.g. '\sum_i a' - lyxerr << "i: " << i << " d: " << d << " best: " << best_dist << endl; - if (d <= best_dist) { - best_dist = d; - setCursor(it, false); - } - if (it == et) - break; - it.forwardPos(); - } + // we should not come here. + BOOST_ASSERT(false); } void LCursor::handleFont(string const & font) { - lyxerr << "LCursor::handleFont: " << font << endl; + lyxerr[Debug::DEBUG] << BOOST_CURRENT_FUNCTION << ": " << font << endl; string safe; if (selection()) { macroModeClose(); @@ -1037,8 +1036,8 @@ string LCursor::selectionAsString(bool label) const ParagraphList & pars = text()->paragraphs(); // should be const ... - par_type startpit = selBegin().par(); - par_type endpit = selEnd().par(); + pit_type startpit = selBegin().pit(); + pit_type endpit = selEnd().pit(); size_t const startpos = selBegin().pos(); size_t const endpos = selEnd().pos(); @@ -1050,7 +1049,7 @@ string LCursor::selectionAsString(bool label) const asString(buffer, startpos, pars[startpit].size(), label) + "\n\n"; // The paragraphs in between (if any) - for (par_type pit = startpit + 1; pit != endpit; ++pit) { + for (pit_type pit = startpit + 1; pit != endpit; ++pit) { Paragraph & par = pars[pit]; result += par.asString(buffer, 0, par.size(), label) + "\n\n"; } @@ -1077,7 +1076,7 @@ string LCursor::currentState() } if (inTexted()) - return text()->currentState(*this); + return text()->currentState(*this); return string(); } @@ -1098,13 +1097,13 @@ Encoding const * LCursor::getEncoding() const int s = 0; // go up until first non-0 text is hit // (innermost text is 0 in mathed) - for (s = size() - 1; s >= 0; --s) + for (s = depth() - 1; s >= 0; --s) if (operator[](s).text()) break; CursorSlice const & sl = operator[](s); - LyXText & text = *sl.text(); - LyXFont font = text.getPar(sl.par()).getFont( - bv().buffer()->params(), sl.pos(), outerFont(sl.par(), text.paragraphs())); + LyXText const & text = *sl.text(); + LyXFont font = text.getPar(sl.pit()).getFont( + bv().buffer()->params(), sl.pos(), outerFont(sl.pit(), text.paragraphs())); return font.language()->encoding(); } @@ -1121,7 +1120,71 @@ void LCursor::dispatched() } +void LCursor::needsUpdate() +{ + disp_.update(true); +} + + void LCursor::noUpdate() { disp_.update(false); } + + +LyXFont LCursor::getFont() const +{ + // HACK. far from being perfect... + int s = 0; + // go up until first non-0 text is hit + // (innermost text is 0 in mathed) + for (s = depth() - 1; s >= 0; --s) + if (operator[](s).text()) + break; + CursorSlice const & sl = operator[](s); + LyXText const & text = *sl.text(); + LyXFont font = text.getPar(sl.pit()).getFont( + bv().buffer()->params(), + sl.pos(), + outerFont(sl.pit(), text.paragraphs())); + + return font; +} + + +void LCursor::fixIfBroken() +{ + // find out last good level + LCursor copy = *this; + size_t newdepth = depth(); + while (!copy.empty()) { + if (copy.idx() > copy.lastidx()) { + lyxerr << "wrong idx " << copy.idx() + << ", max is " << copy.lastidx() + << " at level " << copy.depth() + << ". Trying to correct this." << endl; + newdepth = copy.depth() - 1; + } + else if (copy.pit() > copy.lastpit()) { + lyxerr << "wrong pit " << copy.pit() + << ", max is " << copy.lastpit() + << " at level " << copy.depth() + << ". Trying to correct this." << endl; + newdepth = copy.depth() - 1; + } + else if (copy.pos() > copy.lastpos()) { + lyxerr << "wrong pos " << copy.pos() + << ", max is " << copy.lastpos() + << " at level " << copy.depth() + << ". Trying to correct this." << endl; + newdepth = copy.depth() - 1; + } + copy.pop(); + } + // shrink cursor to a size where everything is valid, possibly + // leaving insets + while (depth() > newdepth) { + pop(); + lyxerr << "correcting cursor to level " << depth() << endl; + } +}