X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fcursor.C;h=a9fd17e47b3a70f975964267243c0d236f251b4f;hb=530749439472bddf13d9f4ee74ee6184ef76e3f9;hp=63194839f781c9190e9f527f99779b457a6458a6;hpb=edbef46cd7865dab72ab6b503d62e2492479d297;p=lyx.git diff --git a/src/cursor.C b/src/cursor.C index 63194839f7..a9fd17e47b 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" @@ -42,13 +43,16 @@ #include "support/limited_stack.h" #include "frontends/LyXView.h" +#include "frontends/font_metrics.h" #include +#include #include #include +#include -using lyx::par_type; +using lyx::pit_type; using std::string; using std::vector; @@ -61,15 +65,15 @@ using std::swap; namespace { - bool positionable - (DocIterator const & cursor, DocIterator const & anchor) + bool + positionable(DocIterator const & cursor, DocIterator const & anchor) { // avoid deeper nested insets when selecting - if (cursor.size() > anchor.size()) + if (cursor.depth() > anchor.depth()) return false; // anchor might be deeper, should have same path then - for (size_t i = 0; i < cursor.size(); ++i) + for (size_t i = 0; i < cursor.depth(); ++i) if (&cursor[i].inset() != &anchor[i].inset()) return false; @@ -79,25 +83,28 @@ namespace { // 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 = 1e10; + double best_dist = std::numeric_limits::max(); DocIterator result; DocIterator it = c; - it.back().pos() = 0; + it.top().pos() = 0; DocIterator et = c; - et.back().pos() = et.back().asMathInset()->cell(et.back().idx()).size(); + et.top().pos() = et.top().asMathInset()->cell(et.top().idx()).size(); for (int i = 0; ; ++i) { - int xo, yo; + int xo; + int yo; LCursor cur = c; cur.setCursor(it); - cur.inset().getCursorPos(cur, xo, yo); + cur.inset().getCursorPos(cur.top(), 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; + lyxerr[Debug::DEBUG] << "i: " << i << " d: " << d + << " best: " << best_dist << endl; if (d <= best_dist) { best_dist = d; result = it; @@ -115,31 +122,21 @@ namespace { int x, int y, int xlow, int xhigh, int ylow, int yhigh) { BOOST_ASSERT(!cursor.empty()); - par_type beg, end; CursorSlice bottom = cursor[0]; - LyXText * text = bottom.text(); - BOOST_ASSERT(text); - getParsInRange(text->paragraphs(), ylow, yhigh, beg, end); - DocIterator it = doc_iterator_begin(cursor.bv().buffer()->inset()); - DocIterator et = doc_iterator_end(cursor.bv().buffer()->inset()); - //lyxerr << "x: " << x << " y: " << y << endl; - //lyxerr << "xlow: " << xlow << " ylow: " << ylow << endl; - //lyxerr << "xhigh: " << xhigh << " yhigh: " << yhigh << endl; + DocIterator it = doc_iterator_begin(bottom.inset()); + DocIterator const et = doc_iterator_end(bottom.inset()); - it.par() = beg; - //et.par() = text->parOffset(end); - - double best_dist = 10e10; - DocIterator best_cursor = it; + double best_dist = std::numeric_limits::max();; + DocIterator best_cursor = et; for ( ; it != et; it.forwardPos()) { // avoid invalid nesting when selecting - if (!cursor.selection() || positionable(it, cursor.anchor_)) { - int xo = 0, yo = 0; - LCursor cur = cursor; - cur.setCursor(it); - cur.inset().getCursorPos(cur, xo, yo); + if (bv_funcs::status(&cursor.bv(), it) == bv_funcs::CUR_INSIDE + && (!cursor.selection() || positionable(it, cursor.anchor_))) { + Point p = bv_funcs::getPos(it); + 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; @@ -155,15 +152,19 @@ namespace { } //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl; - if (best_dist < 1e10) + if (best_cursor != et) { cursor.setCursor(best_cursor); - return best_dist < 1e10; - } + 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) @@ -190,18 +191,22 @@ void LCursor::setCursor(DocIterator const & cur) void LCursor::dispatch(FuncRequest const & cmd0) { - lyxerr[Debug::DEBUG] << "LCursor::dispatch: cmd: " << cmd0 << endl << *this << endl; + lyxerr[Debug::DEBUG] << BOOST_CURRENT_FUNCTION + << " cmd: " << cmd0 << '\n' + << *this << endl; if (empty()) return; + fixIfBroken(); FuncRequest cmd = cmd0; LCursor safe = *this; - for (; size(); pop()) { - lyxerr[Debug::DEBUG] << "LCursor::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. @@ -228,33 +233,6 @@ DispatchResult LCursor::result() const } -bool LCursor::getStatus(FuncRequest const & cmd, FuncStatus & status) -{ - // 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; -} - - BufferView & LCursor::bv() const { BOOST_ASSERT(bv_); @@ -272,7 +250,7 @@ Buffer & LCursor::buffer() const void LCursor::pop() { - BOOST_ASSERT(size() >= 1); + BOOST_ASSERT(depth() >= 1); pop_back(); } @@ -320,7 +298,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; @@ -329,31 +307,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); + x = p.x_; + y = p.y_; } @@ -390,9 +348,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(); } @@ -403,16 +361,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(); } @@ -420,7 +378,7 @@ DocIterator LCursor::selectionBegin() const { if (!selection()) return *this; - return anchor() < back() ? anchor_ : *this; + return anchor() < top() ? anchor_ : *this; } @@ -428,7 +386,7 @@ DocIterator LCursor::selectionEnd() const { if (!selection()) return *this; - return anchor() > back() ? anchor_ : *this; + return anchor() > top() ? anchor_ : *this; } @@ -439,7 +397,7 @@ void LCursor::setSelection() #ifdef WITH_WARNINGS #warning doesnt look ok #endif - if (par() == anchor().par() && pos() == anchor().pos()) + if (pit() == anchor().pit() && pos() == anchor().pos()) selection() = false; } @@ -508,15 +466,15 @@ void LCursor::selHandle(bool sel) std::ostream & operator<<(std::ostream & os, LCursor const & cur) { os << "\n cursor: | anchor:\n"; - for (size_t i = 0, n = cur.size(); i != n; ++i) { - os << " " << cur.operator[](i) << " | "; - if (i < cur.anchor_.size()) + 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_ @@ -568,7 +526,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; @@ -612,9 +570,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)); } @@ -663,7 +621,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()) { @@ -795,7 +753,7 @@ void LCursor::macroModeClose() return; MathUnknownInset * p = activeMacro(); p->finalize(); - string s = p->name(); + string const s = p->name(); --pos(); cell().erase(pos()); @@ -844,6 +802,18 @@ 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) @@ -955,10 +925,6 @@ 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; @@ -970,7 +936,7 @@ bool LCursor::goUpDown(bool up) //} // 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)) { @@ -989,7 +955,8 @@ bool LCursor::goUpDown(bool up) } // any improvement so far? - int xnew, ynew; + int xnew; + int ynew; getPos(xnew, ynew); if (up ? ynew < yo : ynew > yo) return true; @@ -1057,8 +1024,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(); @@ -1070,7 +1037,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"; } @@ -1097,7 +1064,7 @@ string LCursor::currentState() } if (inTexted()) - return text()->currentState(*this); + return text()->currentState(*this); return string(); } @@ -1118,13 +1085,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(); } @@ -1151,3 +1118,61 @@ 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; + } +}