X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fcursor.C;h=e72426f64753af016508c789645b98736ca49466;hb=41ecabf5197a74719dd125e974b062184208c96b;hp=0722215073d2200be904fb7653098db50cdd3776;hpb=22590a98b36977c2257c66dc2d2a72741432d261;p=lyx.git diff --git a/src/cursor.C b/src/cursor.C index 0722215073..e72426f647 100644 --- a/src/cursor.C +++ b/src/cursor.C @@ -12,30 +12,47 @@ #include -#include "buffer.h" #include "BufferView.h" +#include "buffer.h" #include "cursor.h" +#include "coordcache.h" +#include "CutAndPaste.h" #include "debug.h" #include "dispatchresult.h" +#include "encoding.h" #include "funcrequest.h" -#include "iterators.h" +#include "language.h" #include "lfuns.h" +#include "lyxfont.h" +#include "lyxfunc.h" // only for setMessage() #include "lyxrc.h" -#include "lyxtext.h" #include "lyxrow.h" +#include "lyxtext.h" #include "paragraph.h" +#include "paragraph_funcs.h" +#include "pariterator.h" #include "insets/updatableinset.h" #include "insets/insettabular.h" #include "insets/insettext.h" #include "mathed/math_data.h" -#include "mathed/math_hullinset.h" -#include "mathed/math_support.h" +#include "mathed/math_inset.h" +#include "mathed/math_macrotable.h" #include "support/limited_stack.h" +#include "frontends/LyXView.h" +#include "frontends/font_metrics.h" + #include +#include +#include + +#include +#include + +using lyx::pit_type; using std::string; using std::vector; @@ -46,325 +63,268 @@ 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; -// our own cut buffer -limited_stack theCutBuffer; - - -LCursor::LCursor(BufferView & bv) - : cursor_(1), anchor_(1), bv_(&bv), current_(0), - cached_y_(0), x_target_(-1), - selection_(false), mark_(false) -{} - - -void LCursor::reset() -{ - cursor_.clear(); - anchor_.clear(); - cursor_.push_back(CursorSlice()); - anchor_.push_back(CursorSlice()); - current_ = 0; - cached_y_ = 0; - clearTargetX(); - selection_ = false; - mark_ = 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; + } -DispatchResult LCursor::dispatch(FuncRequest const & cmd0) -{ - //lyxerr << "\nLCursor::dispatch: cmd: " << cmd0 << endl << *this << endl; - FuncRequest cmd = cmd0; - for (int i = cursor_.size() - 1; i >= 1; --i) { - current_ = i; - CursorSlice const & citem = cursor_[i]; - lyxerr << "trying to dispatch to inset " << citem.inset_ << endl; - DispatchResult res = inset()->dispatch(*this, cmd); - if (res.dispatched()) { - lyxerr << " successfully dispatched to inset " << citem.inset_ << endl; - return DispatchResult(true, true); - } - // remove one level of cursor - switch (res.val()) { - case FINISHED: - pop(i); - cmd = FuncRequest(LFUN_FINISHED_LEFT); - break; - case FINISHED_RIGHT: - pop(i); - cmd = FuncRequest(LFUN_FINISHED_RIGHT); - break; - case FINISHED_UP: - pop(i); - cmd = FuncRequest(LFUN_FINISHED_UP); - break; - case FINISHED_DOWN: - pop(i); - cmd = FuncRequest(LFUN_FINISHED_DOWN); - break; - default: - lyxerr << "not handled on level " << i << " val: " << res.val() << endl; + // 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; } - lyxerr << "trying to dispatch to main text " << bv_->text() << endl; - DispatchResult res = bv_->text()->dispatch(*this, cmd); - lyxerr << " result: " << res.val() << endl; - return res; -} -void LCursor::push(InsetBase * inset) -{ - lyxerr << "LCursor::push() inset: " << inset << endl; - cursor_.push_back(CursorSlice(inset)); - anchor_.push_back(CursorSlice(inset)); - ++current_; - updatePos(); -} - - -void LCursor::pop(int depth) -{ - //lyxerr << "LCursor::pop() to depth " << depth << endl; - while (int(cursor_.size()) > depth) - pop(); -} + /// 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; + } -void LCursor::pop() -{ - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "LCursor::pop() a level" << endl; - if (cursor_.size() <= 1) - lyxerr << "### TRYING TO POP FROM EMPTY CURSOR" << endl; - else { - cursor_.pop_back(); - anchor_.pop_back(); - current_ = cursor_.size() - 1; + return false; } - //lyxerr << "LCursor::pop() current now: " << current_ << endl; -} +} // namespace anon -void LCursor::pushLeft(InsetBase * p) -{ - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "Entering inset " << t << " left" << endl; - push(p); - p->idxFirst(*this); -} - -bool LCursor::popLeft() -{ - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "Leaving inset to the left" << endl; - if (depth() <= 1) { - if (depth() == 1) - inset()->notifyCursorLeaves(idx()); - return false; - } - inset()->notifyCursorLeaves(idx()); - pop(); - return true; -} +// 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), logicalpos_(false) +{} -bool LCursor::popRight() +void LCursor::reset(InsetBase & inset) { - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "Leaving inset to the right" << endl; - if (depth() <= 1) { - if (depth() == 1) - inset()->notifyCursorLeaves(idx()); - return false; - } - inset()->notifyCursorLeaves(idx()); - pop(); - posRight(); - return true; + clear(); + push_back(CursorSlice(inset)); + anchor_ = DocIterator(inset); + clearTargetX(); + selection_ = false; + mark_ = false; } -CursorSlice & LCursor::current() +// this (intentionally) does neither touch anchor nor selection status +void LCursor::setCursor(DocIterator const & cur) { - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "accessing cursor slice " << current_ - // << ": " << cursor_[current_] << endl; - return cursor_[current_]; + DocIterator::operator=(cur); } -CursorSlice const & LCursor::current() const +void LCursor::dispatch(FuncRequest const & cmd0) { - //lyxerr << "accessing cursor slice " << current_ - // << ": " << cursor_[current_] << endl; - return cursor_[current_]; -} - + lyxerr[Debug::DEBUG] << BOOST_CURRENT_FUNCTION + << " cmd: " << cmd0 << '\n' + << *this << endl; + if (empty()) + return; -int LCursor::currentMode() -{ - BOOST_ASSERT(!cursor_.empty()); - for (int i = cursor_.size() - 1; i >= 1; --i) { - int res = cursor_[i].inset()->currentMode(); - if (res != MathInset::UNDECIDED_MODE) - return res; + fixIfBroken(); + FuncRequest cmd = cmd0; + LCursor safe = *this; + + for (; depth(); pop()) { + lyxerr[Debug::DEBUG] << "LCursor::dispatch: cmd: " + << cmd0 << endl << *this << endl; + BOOST_ASSERT(pos() <= lastpos()); + BOOST_ASSERT(idx() <= lastidx()); + 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. + // The handler can reset the update and val flags if necessary. + disp_.update(true); + disp_.dispatched(true); + inset().dispatch(*this, cmd); + if (disp_.dispatched()) + break; } - return MathInset::TEXT_MODE; -} - - -LyXText * LCursor::innerText() const -{ - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "LCursor::innerText() depth: " << cursor_.size() << endl; - if (cursor_.size() > 1) { - // go up until first non-0 text is hit - // (innermost text is 0 in mathed) - for (int i = cursor_.size() - 1; i >= 1; --i) - if (cursor_[i].text()) - return cursor_[i].text(); + // it completely to get a 'bomb early' behaviour in case this + // object will be used again. + if (!disp_.dispatched()) { + lyxerr[Debug::DEBUG] << "RESTORING OLD CURSOR!" << endl; + operator=(safe); + disp_.dispatched(false); } - return bv_->text(); } -CursorSlice const & LCursor::innerTextSlice() const +DispatchResult LCursor::result() const { - BOOST_ASSERT(!cursor_.empty()); - //lyxerr << "LCursor::innerTextSlice() depth: " << cursor_.size() << endl; - if (cursor_.size() > 1) { - // go up until first non-0 text is hit - // (innermost text is 0 in mathed) - for (int i = cursor_.size() - 1; i >= 1; --i) - if (cursor_[i].text()) - return cursor_[i]; - } - return cursor_[0]; + return disp_; } -void LCursor::updatePos() +BufferView & LCursor::bv() const { - BOOST_ASSERT(!cursor_.empty()); - if (cursor_.size() > 1) - cached_y_ = bv_->top_y() + cursor_.back().inset()->yo(); - //cached_y_ = cursor_.back().inset()->yo(); + BOOST_ASSERT(bv_); + return *bv_; } -void LCursor::getDim(int & asc, int & des) const +Buffer & LCursor::buffer() const { - BOOST_ASSERT(!cursor_.empty()); - LyXText * text = innerText(); -#warning crashes with text-in-math - if (0 && text) { - RowList::iterator const rit = text->cursorRow(); - if (rit != text->endRow()) { - asc = rit->baseline(); - des = rit->height() - asc; - } else { - asc = 10; - des = 10; - } - } else { - asc = 10; - des = 10; - //innerInset()->getCursorDim(asc, des); - } + BOOST_ASSERT(bv_); + BOOST_ASSERT(bv_->buffer()); + return *bv_->buffer(); } -void LCursor::getPos(int & x, int & y) const +void LCursor::pop() { - BOOST_ASSERT(!cursor_.empty()); - x = 0; - y = 0; - if (cursor_.size() <= 1) { - x = bv_->text()->cursorX(cursor_.front()); - y = bv_->text()->cursorY(cursor_.front()); - } else { - inset()->getCursorPos(cursor_.back(), x, y); - // getCursorPos gives _screen_ coordinates. We need to add - // top_y to get document coordinates. This is hidden in cached_y_. - //y += cached_y_ - inset()->yo(); - // The rest is non-obvious. The reason we have to have these - // extra computation is that the getCursorPos() calls rely - // on the inset's own knowledge of its screen position. - // If we scroll up or down in a big enough increment, - // inset->draw() is not called: this doesn't update - // inset.yo_, so getCursor() returns an old value. - // Ugly as you like. - } - lyxerr << "#### LCursor::getPos: x: " << x << " y: " << y << endl; + BOOST_ASSERT(depth() >= 1); + pop_back(); } -void LCursor::paste(string const & data) +void LCursor::push(InsetBase & p) { - dispatch(FuncRequest(LFUN_PASTE, data)); + push_back(CursorSlice(p)); } -InsetBase * LCursor::innerInsetOfType(int code) const +void LCursor::pushLeft(InsetBase & p) { - for (int i = cursor_.size() - 1; i >= 1; --i) - if (cursor_[i].inset_->lyxCode() == code) - return cursor_[i].inset_; - return 0; + BOOST_ASSERT(!empty()); + //lyxerr << "Entering inset " << t << " left" << endl; + push(p); + p.idxFirst(*this); } -InsetTabular * LCursor::innerInsetTabular() const +bool LCursor::popLeft() { - return static_cast(innerInsetOfType(InsetBase::TABULAR_CODE)); + BOOST_ASSERT(!empty()); + //lyxerr << "Leaving inset to the left" << endl; + inset().notifyCursorLeaves(*this); + if (depth() == 1) + return false; + pop(); + return true; } -void LCursor::resetAnchor() +bool LCursor::popRight() { - anchor_ = cursor_; + BOOST_ASSERT(!empty()); + //lyxerr << "Leaving inset to the right" << endl; + inset().notifyCursorLeaves(*this); + if (depth() == 1) + return false; + pop(); + ++pos(); + return true; } -BufferView & LCursor::bv() const +int LCursor::currentMode() { - return *bv_; + BOOST_ASSERT(!empty()); + for (int i = depth() - 1; i >= 0; --i) { + int res = operator[](i).inset().currentMode(); + if (res != InsetBase::UNDECIDED_MODE) + return res; + } + return InsetBase::TEXT_MODE; } -MathAtom const & LCursor::prevAtom() const +void LCursor::getPos(int & x, int & y) const { - BOOST_ASSERT(pos() > 0); - return cell()[pos() - 1]; + Point p = bv_funcs::getPos(*this, boundary()); + x = p.x_; + y = p.y_; } -MathAtom & LCursor::prevAtom() +void LCursor::paste(string const & data) { - BOOST_ASSERT(pos() > 0); - return cell()[pos() - 1]; + dispatch(FuncRequest(LFUN_PASTE, data)); } -MathAtom const & LCursor::nextAtom() const +void LCursor::resetAnchor() { - BOOST_ASSERT(pos() < lastpos()); - return cell()[pos()]; + anchor_ = *this; } -MathAtom & LCursor::nextAtom() -{ - BOOST_ASSERT(pos() < lastpos()); - return cell()[pos()]; -} - bool LCursor::posLeft() { @@ -384,66 +344,71 @@ bool LCursor::posRight() } -CursorSlice & LCursor::anchor() -{ - return anchor_.back(); -} - - -CursorSlice const & LCursor::anchor() const +CursorSlice LCursor::anchor() const { - return anchor_.back(); + 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(); + } + return normal; } -CursorSlice const & LCursor::selBegin() const +CursorSlice LCursor::selBegin() const { if (!selection()) - return cursor_.back(); - // can't use std::min as this creates a new object - return anchor() < cursor_.back() ? anchor() : cursor_.back(); + return top(); + return anchor() < top() ? anchor() : top(); } -CursorSlice & LCursor::selBegin() +CursorSlice LCursor::selEnd() const { if (!selection()) - return cursor_.back(); - return anchor() < cursor_.back() ? anchor() : cursor_.back(); + return top(); + return anchor() > top() ? anchor() : top(); } -CursorSlice const & LCursor::selEnd() const +DocIterator LCursor::selectionBegin() const { if (!selection()) - return cursor_.back(); - return anchor() > cursor_.back() ? anchor() : cursor_.back(); + return *this; + return anchor() < top() ? anchor_ : *this; } -CursorSlice & LCursor::selEnd() +DocIterator LCursor::selectionEnd() const { - if (selection()) - return cursor_.back(); - return anchor() > cursor_.back() ? anchor() : cursor_.back(); + if (!selection()) + return *this; + return anchor() > top() ? anchor_ : *this; } void LCursor::setSelection() { selection() = true; - // a selection with no contents is not a selection - if (par() == anchor().par() && pos() == anchor().pos()) + // A selection with no contents is not a selection +#ifdef WITH_WARNINGS +#warning doesnt look ok +#endif + if (pit() == anchor().pit() && pos() == anchor().pos()) selection() = false; } -void LCursor::setSelection(CursorBase const & where, size_t n) +void LCursor::setSelection(DocIterator const & where, size_t n) { + setCursor(where); selection() = true; - cursor_ = where; anchor_ = where; pos() += n; + // Open all collapsed insets + for (int i = depth() - 1; i >= 0; --i) + operator[](i).inset().setStatus(*this, InsetBase::Open); } @@ -474,347 +439,48 @@ void LCursor::clearTargetX() } -LyXText * LCursor::text() const -{ - return current_ ? current().text() : bv_->text(); -} - - -Paragraph & LCursor::paragraph() -{ - BOOST_ASSERT(!inMathed()); - return current_ ? current().paragraph() : *bv_->text()->getPar(par()); -} - - -Paragraph const & LCursor::paragraph() const -{ - BOOST_ASSERT(!inMathed()); - return current_ ? current().paragraph() : *bv_->text()->getPar(par()); -} - - -LCursor::par_type LCursor::lastpar() const -{ - return inMathed() ? 0 : text()->paragraphs().size() - 1; -} - - -LCursor::pos_type LCursor::lastpos() const -{ - InsetBase * inset = current().inset(); - return inset && inset->asMathInset() ? cell().size() : paragraph().size(); -} - -LCursor::row_type LCursor::crow() const -{ - return paragraph().row(pos()); -} - - -LCursor::row_type LCursor::lastcrow() const -{ - return paragraph().rows.size(); -} - - -size_t LCursor::nargs() const -{ - // assume 1x1 grid for 'plain text' - return current_ ? current().nargs() : 1; -} - - -size_t LCursor::ncols() const -{ - // assume 1x1 grid for 'plain text' - return current_ ? current().ncols() : 1; -} - - -size_t LCursor::nrows() const -{ - // assume 1x1 grid for 'plain text' - return current_ ? current().nrows() : 1; -} - - -LCursor::row_type LCursor::row() const -{ - BOOST_ASSERT(current_ > 0); - return current().row(); -} - - -LCursor::col_type LCursor::col() const -{ - BOOST_ASSERT(current_ > 0); - return current().col(); -} - - -MathArray const & LCursor::cell() const -{ - BOOST_ASSERT(current_ > 0); - return current().cell(); -} - - -MathArray & LCursor::cell() -{ - BOOST_ASSERT(current_ > 0); - return current().cell(); -} - - -void LCursor::info(std::ostream & os) +void LCursor::info(std::ostream & os) const { for (int i = 1, n = depth(); i < n; ++i) { - cursor_[i].inset()->infoize(os); + operator[](i).inset().infoize(os); os << " "; } -#warning FIXME - //if (pos() != 0) - // prevAtom()->infoize2(os); + if (pos() != 0) + prevInset()->infoize2(os); // overwite old message os << " "; } -namespace { - -void region(CursorSlice const & i1, CursorSlice const & i2, - LCursor::row_type & r1, LCursor::row_type & r2, - LCursor::col_type & c1, LCursor::col_type & c2) -{ - InsetBase * p = i1.inset(); - c1 = p->col(i1.idx_); - c2 = p->col(i2.idx_); - if (c1 > c2) - swap(c1, c2); - r1 = p->row(i1.idx_); - r2 = p->row(i2.idx_); - if (r1 > r2) - swap(r1, r2); -} - -} - - -string LCursor::grabSelection() -{ - if (!selection()) - return string(); - - CursorSlice i1 = selBegin(); - CursorSlice i2 = selEnd(); - - if (i1.idx_ == i2.idx_) { - if (i1.inset()->asMathInset()) { - MathArray::const_iterator it = i1.cell().begin(); - return asString(MathArray(it + i1.pos_, it + i2.pos_)); - } else { - return "unknown selection 1"; - } - } - - row_type r1, r2; - col_type c1, c2; - region(i1, i2, r1, r2, c1, c2); - - string data; - if (i1.inset()->asMathInset()) { - for (row_type row = r1; row <= r2; ++row) { - if (row > r1) - data += "\\\\"; - for (col_type col = c1; col <= c2; ++col) { - if (col > c1) - data += '&'; - data += asString(i1.asMathInset()->cell(i1.asMathInset()->index(row, col))); - } - } - } else { - data = "unknown selection 2"; - } - return data; -} - - -void LCursor::eraseSelection() -{ - CursorSlice i1 = selBegin(); - CursorSlice i2 = selEnd(); -#warning FIXME - if (i1.inset()->asMathInset()) { - if (i1.idx_ == i2.idx_) { - i1.cell().erase(i1.pos_, i2.pos_); - } else { - MathInset * p = i1.asMathInset(); - row_type r1, r2; - col_type c1, c2; - region(i1, i2, r1, r2, c1, c2); - for (row_type row = r1; row <= r2; ++row) - for (col_type col = c1; col <= c2; ++col) - p->cell(p->index(row, col)).clear(); - } - current() = i1; - } else { - lyxerr << "can't erase this selection 1" << endl; - } -} - - -string LCursor::grabAndEraseSelection() -{ - if (!selection()) - return string(); - string res = grabSelection(); - eraseSelection(); - selection() = false; - return res; -} - - -void LCursor::selClear() -{ - resetAnchor(); - clearSelection(); -} - - -void LCursor::selCopy() -{ - if (selection()) { - theCutBuffer.push(grabSelection()); - selection() = false; - } else { - //theCutBuffer.erase(); - } -} - - -void LCursor::selCut() -{ - theCutBuffer.push(grabAndEraseSelection()); -} - - -void LCursor::selDel() -{ - if (selection()) { - eraseSelection(); - selection() = false; - } -} - - -void LCursor::selPaste(size_t n) -{ - selClearOrDel(); - if (n < theCutBuffer.size()) - paste(theCutBuffer[n]); - //grabSelection(); - selection() = false; -} - - void LCursor::selHandle(bool sel) { + //lyxerr << "LCursor::selHandle" << endl; if (sel == selection()) return; - resetAnchor(); - selection() = sel; -} - -void LCursor::selStart() -{ resetAnchor(); - selection() = true; -} - - -void LCursor::selClearOrDel() -{ - if (lyxrc.auto_region_delete) - selDel(); - else - selection() = false; + selection() = sel; } std::ostream & operator<<(std::ostream & os, LCursor const & cur) { - os << "\n"; - for (size_t i = 0, n = cur.cursor_.size(); i != n; ++i) - os << " (" << cur.cursor_[i] << " | " << cur.anchor_[i] << "\n"; - return os << "current: " << cur.current_ << endl; -} - - - - -// -// CursorBase -// - - -void increment(CursorBase & it) -{ - CursorSlice & top = it.back(); - MathArray & ar = top.asMathInset()->cell(top.idx_); - - // move into the current inset if possible - // it is impossible for pos() == size()! - MathInset * n = 0; - if (top.pos() != top.lastpos()) - n = (ar.begin() + top.pos_)->nucleus(); - if (n && n->isActive()) { - it.push_back(CursorSlice(n)); - return; + 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"; } - - // otherwise move on one cell back if possible - if (top.pos() < top.lastpos()) { - // pos() == lastpos() is valid! - ++top.pos_; - return; + for (size_t i = cur.depth(), n = cur.anchor_.depth(); i < n; ++i) { + os << "------------------------------- | " << cur.anchor_[i] << "\n"; } - - // otherwise try to move on one cell if possible - while (top.idx() < top.lastidx()) { - ++top.idx_; - if (top.asMathInset()->validCell(top.idx_)) { - top.pos_ = 0; - return; - } - } - - // otherwise leave array, move on one back - // this might yield pos() == size(), but that's a ok. - it.pop_back(); - // it certainly invalidates top - ++it.back().pos_; -} - - -CursorBase ibegin(InsetBase * p) -{ - CursorBase it; - it.push_back(CursorSlice(p)); - return it; -} - - -CursorBase iend(InsetBase * p) -{ - CursorBase it; - it.push_back(CursorSlice(p)); - CursorSlice & cur = it.back(); - cur.idx() = cur.lastidx(); - cur.pos() = cur.lastpos(); - return it; + os << " selection: " << cur.selection_ + << " x_target: " << cur.x_target_ << endl; + return os; } @@ -824,20 +490,16 @@ CursorBase iend(InsetBase * p) // // The part below is the non-integrated rest of the original math // cursor. This should be either generalized for texted or moved -// back to the math insets. +// back to mathed (in most cases to MathNestInset). // /////////////////////////////////////////////////////////////////// -#include "mathed/math_braceinset.h" #include "mathed/math_charinset.h" -#include "mathed/math_commentinset.h" #include "mathed/math_factory.h" #include "mathed/math_gridinset.h" #include "mathed/math_macroarg.h" -#include "mathed/math_macrotemplate.h" #include "mathed/math_mathmlstream.h" #include "mathed/math_scriptinset.h" -#include "mathed/math_spaceinset.h" #include "mathed/math_support.h" #include "mathed/math_unknowninset.h" @@ -845,132 +507,54 @@ CursorBase iend(InsetBase * p) bool LCursor::isInside(InsetBase const * p) -{ - for (unsigned i = 0; i < depth(); ++i) - if (cursor_[i].inset() == p) - return true; - return false; -} - - -bool LCursor::openable(MathAtom const & t) -{ - if (!t->isActive()) - return false; - - if (t->lock()) - return false; - - if (!selection()) - return true; - - // we can't move into anything new during selection - if (depth() == anchor_.size()) - return false; - if (t.nucleus() != anchor_[depth()].inset()) - return false; - - return true; -} - - -bool LCursor::inNucleus() -{ - return inset()->asMathInset()->asScriptInset() && idx() == 2; -} - - -bool LCursor::left() -{ - autocorrect() = false; - clearTargetX(); - if (inMacroMode()) { - macroModeClose(); - return true; - } - - if (pos() != 0 && openable(prevAtom())) { - posLeft(); - push(nextAtom().nucleus()); - inset()->idxLast(*this); - return true; - } - - return posLeft() || idxLeft() || popLeft() || selection(); +{ + for (size_t i = 0; i != depth(); ++i) + if (&operator[](i).inset() == p) + return true; + return false; } -bool LCursor::right() +void LCursor::leaveInset(InsetBase const & inset) { - autocorrect() = false; - clearTargetX(); - if (inMacroMode()) { - macroModeClose(); - return true; - } - - if (pos() != lastpos() && openable(nextAtom())) { - pushLeft(nextAtom().nucleus()); - inset()->idxFirst(*this); - return true; + for (size_t i = 0; i != depth(); ++i) { + if (&operator[](i).inset() == &inset) { + resize(i); + return; + } } - - return posRight() || idxRight() || popRight() || selection(); } -bool positionable(CursorBase const & cursor, CursorBase const & anchor) +bool LCursor::openable(MathAtom const & t) const { - // avoid deeper nested insets when selecting - if (cursor.size() > anchor.size()) + if (!t->isActive()) 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) -{ - bool res = bruteFind(x, y, formula()->xlow(), formula()->xhigh(), - formula()->ylow(), formula()->yhigh()); - if (!res) { - // this can happen on creation of "math-display" - idx() = 0; - pos() = 0; - } - clearTargetX(); -} + if (t->lock()) + return false; + if (!selection()) + return true; + // we can't move into anything new during selection + if (depth() >= anchor_.depth()) + return false; + if (!ptr_cmp(t.nucleus(), &anchor_[depth()].inset())) + return false; -bool LCursor::home() -{ - autocorrect() = false; - macroModeClose(); - if (!inset()->idxHome(*this)) - return popLeft(); - clearTargetX(); return true; } -bool LCursor::end() +void LCursor::setScreenPos(int x, int y) { - autocorrect() = false; - macroModeClose(); - if (!inset()->idxEnd(*this)) - return popRight(); - clearTargetX(); - return true; + x_target() = x; + bruteFind(*this, x, y, 0, bv().workWidth(), 0, bv().workHeight()); } + void LCursor::plainErase() { cell().erase(pos()); @@ -979,7 +563,7 @@ void LCursor::plainErase() void LCursor::markInsert() { - cell().insert(pos(), MathAtom(new MathCharInset(0))); + insert(char(0)); } @@ -996,42 +580,47 @@ void LCursor::plainInsert(MathAtom const & t) } -void LCursor::insert2(string const & str) -{ - MathArray ar; - asArray(str, ar); - insert(ar); -} - - void LCursor::insert(string const & str) { - lyxerr << "inserting '" << str << "'" << endl; - selClearOrDel(); - for (string::const_iterator it = str.begin(); it != str.end(); ++it) - plainInsert(MathAtom(new MathCharInset(*it))); + for_each(str.begin(), str.end(), + boost::bind(static_cast + (&LCursor::insert), this, _1)); } void LCursor::insert(char c) { - lyxerr << "inserting '" << c << "'" << endl; - selClearOrDel(); - plainInsert(MathAtom(new MathCharInset(c))); + //lyxerr << "LCursor::insert char '" << c << "'" << endl; + BOOST_ASSERT(!empty()); + if (inMathed()) { + lyx::cap::selClearOrDel(*this); + insert(new MathCharInset(c)); + } else { + text()->insertChar(*this, c); + } } void LCursor::insert(MathAtom const & t) { + //lyxerr << "LCursor::insert MathAtom '" << t << "'" << endl; macroModeClose(); - selClearOrDel(); + lyx::cap::selClearOrDel(*this); plainInsert(t); } +void LCursor::insert(InsetBase * inset) +{ + if (inMathed()) + insert(MathAtom(inset)); + else + text()->insertInset(*this, inset); +} + + void LCursor::niceInsert(string const & t) { - lyxerr << "*** LCursor::niceInsert 1: " << t << endl; MathArray ar; asArray(t, ar); if (ar.size() == 1) @@ -1043,17 +632,17 @@ void LCursor::niceInsert(string const & t) void LCursor::niceInsert(MathAtom const & t) { - lyxerr << "*** LCursor::niceInsert 2: " << t << endl; macroModeClose(); - string safe = grabAndEraseSelection(); + 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()) { posLeft(); - pushLeft(nextAtom().nucleus()); + // be careful here: don't use 'pushLeft(t)' as this we need to + // push the clone, not the original + pushLeft(*nextInset()); paste(safe); } - lyxerr << "*** LCursor::niceInsert 3: " << t << endl; } @@ -1061,7 +650,7 @@ void LCursor::insert(MathArray const & ar) { macroModeClose(); if (selection()) - eraseSelection(); + lyx::cap::eraseSelection(*this); cell().insert(pos(), ar); pos() += ar.size(); } @@ -1072,12 +661,12 @@ bool LCursor::backspace() autocorrect() = false; if (selection()) { - selDel(); + lyx::cap::selDel(*this); return true; } if (pos() == 0) { - if (inset()->nargs() == 1 && depth() == 1 && lastpos() == 0) + if (inset().nargs() == 1 && depth() == 1 && lastpos() == 0) return false; pullArg(); return true; @@ -1094,8 +683,9 @@ bool LCursor::backspace() if (pos() != 0 && prevAtom()->nargs() > 0) { // let's require two backspaces for 'big stuff' and // highlight on the first + resetAnchor(); selection() = true; - left(); + --pos(); } else { --pos(); plainErase(); @@ -1111,30 +701,32 @@ bool LCursor::erase() return true; if (selection()) { - selDel(); + lyx::cap::selDel(*this); return true; } // delete empty cells if possible - if (pos() == lastpos() && inset()->idxDelete(idx())) + if (pos() == lastpos() && inset().idxDelete(idx())) return true; // special behaviour when in last position of cell if (pos() == lastpos()) { - bool one_cell = inset()->nargs() == 1; + bool one_cell = inset().nargs() == 1; if (one_cell && depth() == 1 && lastpos() == 0) return false; // remove markup if (one_cell) pullArg(); else - inset()->idxGlue(idx()); + inset().idxGlue(idx()); return true; } - if (pos() != lastpos() && inset()->nargs() > 0) { + // 'clever' UI hack: only erase large items if previously slected + if (pos() != lastpos() && inset().nargs() > 0) { + resetAnchor(); selection() = true; - right(); + ++pos(); } else { plainErase(); } @@ -1146,10 +738,10 @@ bool LCursor::erase() bool LCursor::up() { macroModeClose(); - CursorBase save = cursor_; + DocIterator save = *this; if (goUpDown(true)) return true; - cursor_ = save; + setCursor(save); autocorrect() = false; return selection(); } @@ -1158,10 +750,10 @@ bool LCursor::up() bool LCursor::down() { macroModeClose(); - CursorBase save = cursor_; + DocIterator save = *this; if (goUpDown(false)) return true; - cursor_ = save; + setCursor(save); autocorrect() = false; return selection(); } @@ -1173,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()); @@ -1184,11 +776,13 @@ void LCursor::macroModeClose() string const name = s.substr(1); // prevent entering of recursive macros - if (formula()->lyxCode() == InsetOld::MATHMACRO_CODE - && formula()->getInsetName() == name) + // 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)); } @@ -1200,11 +794,12 @@ string LCursor::macroName() void LCursor::handleNest(MathAtom const & a, int c) { + //lyxerr << "LCursor::handleNest: " << c << endl; MathAtom t = a; - asArray(grabAndEraseSelection(), t.nucleus()->cell(c)); + asArray(lyx::cap::grabAndEraseSelection(*this), t.nucleus()->cell(c)); insert(t); posLeft(); - pushLeft(t.nucleus()); + pushLeft(*nextInset()); } @@ -1219,30 +814,21 @@ int LCursor::targetX() const } -MathHullInset * LCursor::formula() const -{ - for (int i = cursor_.size() - 1; i >= 1; --i) - if (cursor_[i].inset()->lyxCode() == InsetBase::MATH_CODE) - return static_cast(cursor_[i].inset()); - return 0; -} - - -void LCursor::adjust(pos_type from, int diff) +void LCursor::setTargetX() { - if (pos() > from) - pos() += diff; - if (anchor().pos_ > from) - anchor().pos_ += diff; - // just to be on the safe side - // theoretically unecessary - normalize(); + // 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(); @@ -1255,50 +841,30 @@ MathUnknownInset * LCursor::activeMacro() } -bool LCursor::inMacroArgMode() const -{ - return pos() > 0 && prevAtom()->getChar() == '#'; -} - - -MathGridInset * LCursor::enclosingGrid(idx_type & idx) const -{ - for (MathInset::difference_type i = depth() - 1; i >= 0; --i) { - MathInset * m = cursor_[i].inset()->asMathInset(); - if (!m) - return 0; - MathGridInset * p = m->asGridInset(); - if (p) { - idx = cursor_[i].idx_; - return p; - } - } - return 0; -} - - void LCursor::pullArg() { -#warning look here -#if 0 +#ifdef WITH_WARNINGS +#warning Look here +#endif MathArray ar = cell(); - if (popLeft()) { + if (popLeft() && inMathed()) { plainErase(); cell().insert(pos(), ar); resetAnchor(); } else { - formula()->mutateToText(); + //formula()->mutateToText(); } -#endif } void LCursor::touch() { +#ifdef WITH_WARNINGS #warning look here +#endif #if 0 - CursorBase::const_iterator it = cursor_.begin(); - CursorBase::const_iterator et = cursor_.end(); + DocIterator::const_iterator it = begin(); + DocIterator::const_iterator et = end(); for ( ; it != et; ++it) it->cell().touch(); #endif @@ -1310,44 +876,30 @@ void LCursor::normalize() if (idx() >= nargs()) { lyxerr << "this should not really happen - 1: " << idx() << ' ' << nargs() - << " in: " << inset() << endl; + << " in: " << &inset() << endl; } - idx() = min(idx(), nargs() - 1); + idx() = min(idx(), lastidx()); if (pos() > lastpos()) { lyxerr << "this should not really happen - 2: " << pos() << ' ' << lastpos() << " in idx: " << idx() << " in atom: '"; WriteStream wi(lyxerr, false, true); - inset()->asMathInset()->write(wi); + inset().asMathInset()->write(wi); lyxerr << endl; } pos() = min(pos(), lastpos()); } -char LCursor::valign() -{ - idx_type idx; - MathGridInset * p = enclosingGrid(idx); - return p ? p->valign() : '\0'; -} - - -char LCursor::halign() -{ - idx_type idx; - MathGridInset * p = enclosingGrid(idx); - return p ? p->halign(idx % p->ncols()) : '\0'; -} - - bool LCursor::goUpDown(bool up) { - // Be warned: The 'logic' implemented in this function is highly fragile. - // A distance of one pixel or a '<' vs '<=' _really_ matters. - // So fiddle around with it only if you know what you are doing! - int xo = 0; + // Be warned: The 'logic' implemented in this function is highly + // fragile. A distance of one pixel or a '<' vs '<=' _really + // matters. So fiddle around with it only if you think you know + // what you are doing! + + int xo = 0; int yo = 0; getPos(xo, yo); @@ -1385,449 +937,254 @@ 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) { - //lyxerr << "updown: We are in " << inset() << " idx: " << idx() << endl; + while (true) { + //lyxerr << "updown: We are in " << &inset() << " idx: " << idx() << endl; // ask inset first - if (inset()->idxUpDown(*this, up)) { + 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; } // no such inset found, just take something "above" //lyxerr << "updown: handled by strange case" << endl; if (!popLeft()) { - return - bruteFind(xo, yo, - formula()->xlow(), - formula()->xhigh(), - up ? formula()->ylow() : yo + 4, - up ? yo - 4 : formula()->yhigh() - ); + int ylow = up ? 0 : yo + 1; + int yhigh = up ? yo - 1 : bv().workHeight(); + 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) -{ - CursorBase best_cursor; - double best_dist = 1e10; - - CursorBase it = ibegin(formula()); - CursorBase et = iend(formula()); - while (1) { - // avoid invalid nesting when selecting - if (!selection() || positionable(it, anchor_)) { - int xo, yo; - CursorSlice & cur = it.back(); - 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 << "x: " << x << " y: " << y << " 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) { - best_dist = d; - best_cursor = it; - } - } - } - - if (it == et) - break; - increment(it); - } - if (best_dist < 1e10) - cursor_ = best_cursor; - return best_dist < 1e10; + // we should not come here. + BOOST_ASSERT(false); } -void LCursor::bruteFind2(int x, int y) +void LCursor::handleFont(string const & font) { - double best_dist = 1e10; + lyxerr[Debug::DEBUG] << BOOST_CURRENT_FUNCTION << ": " << font << endl; + string safe; + if (selection()) { + macroModeClose(); + safe = lyx::cap::grabAndEraseSelection(*this); + } - CursorBase it = cursor_; - it.back().pos(0); - CursorBase et = cursor_; - int n = et.back().asMathInset()->cell(et.back().idx_).size(); - et.back().pos(n); - for (int i = 0; ; ++i) { - int xo, yo; - CursorSlice & cur = it.back(); - 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; - cursor_ = it; + if (lastpos() != 0) { + // something left in the cell + if (pos() == 0) { + // cursor in first position + popLeft(); + } else if (pos() == lastpos()) { + // cursor in last position + popRight(); + } else { + // cursor in between. split cell + MathArray::iterator bt = cell().begin(); + MathAtom at = createMathInset(font); + at.nucleus()->cell(0) = MathArray(bt, bt + pos()); + cell().erase(bt, bt + pos()); + popLeft(); + plainInsert(at); } - if (it == et) - break; - increment(it); + } else { + // nothing left in the cell + pullArg(); + plainErase(); } + insert(safe); } -bool LCursor::idxLineLast() -{ - idx() -= idx() % ncols(); - idx() += ncols() - 1; - pos() = lastpos(); - return true; -} - - -bool LCursor::idxLeft() -{ - return inset()->idxLeft(*this); -} - - -bool LCursor::idxRight() +void LCursor::message(string const & msg) const { - return inset()->idxRight(*this); + bv().owner()->getLyXFunc().setMessage(msg); } -bool LCursor::script(bool up) +void LCursor::errorMessage(string const & msg) const { - // Hack to get \\^ and \\_ working - lyxerr << "handling script: up: " << up << endl; - if (inMacroMode() && macroName() == "\\") { - if (up) - niceInsert(createMathInset("mathcircumflex")); - else - interpret('_'); - return true; - } - - macroModeClose(); - string safe = grabAndEraseSelection(); - if (inNucleus()) { - // we are in a nucleus of a script inset, move to _our_ script - inset()->asMathInset()->asScriptInset()->ensure(up); - idx() = up; - pos() = 0; - } else if (pos() != 0 && prevAtom()->asScriptInset()) { - prevAtom().nucleus()->asScriptInset()->ensure(up); - posLeft(); - push(inset()); - idx() = up; - pos() = lastpos(); - } else if (pos() != 0) { - --pos(); - cell()[pos()] = MathAtom(new MathScriptInset(nextAtom(), up)); - push(inset()); - idx() = up; - pos() = 0; - } else { - plainInsert(MathAtom(new MathScriptInset(up))); - posLeft(); - nextAtom().nucleus()->asScriptInset()->ensure(up); - push(inset()); - idx() = up; - pos() = 0; - } - paste(safe); - return true; + bv().owner()->getLyXFunc().setErrorMessage(msg); } -bool LCursor::interpret(char c) +string LCursor::selectionAsString(bool label) const { - lyxerr << "interpret 2: '" << c << "'" << endl; - clearTargetX(); - if (inMacroArgMode()) { - posLeft(); - plainErase(); -#warning FIXME -#if 0 - int n = c - '0'; - MathMacroTemplate const * p = formula()->asMacroTemplate(); - if (p && 1 <= n && n <= p->numargs()) - insert(MathAtom(new MathMacroArgument(c - '0'))); - else { - insert(createMathInset("#")); - interpret(c); // try again - } -#endif - return true; - } - - // handle macroMode - if (inMacroMode()) { - string name = macroName(); - //lyxerr << "interpret name: '" << name << "'" << endl; + if (!selection()) + return string(); - if (isalpha(c)) { - activeMacro()->setName(activeMacro()->name() + c); - return true; - } + if (inTexted()) { + Buffer const & buffer = *bv().buffer(); + ParagraphList & pars = text()->paragraphs(); - // handle 'special char' macros - if (name == "\\") { - // remove the '\\' - backspace(); - if (c == '\\') { - if (currentMode() == MathInset::TEXT_MODE) - niceInsert(createMathInset("textbackslash")); - else - niceInsert(createMathInset("backslash")); - } else if (c == '{') { - niceInsert(MathAtom(new MathBraceInset)); - } else { - niceInsert(createMathInset(string(1, c))); - } - return true; - } + // should be const ... + pit_type startpit = selBegin().pit(); + pit_type endpit = selEnd().pit(); + size_t const startpos = selBegin().pos(); + size_t const endpos = selEnd().pos(); - // leave macro mode and try again if necessary - macroModeClose(); - if (c == '{') - niceInsert(MathAtom(new MathBraceInset)); - else if (c != ' ') - interpret(c); - return true; - } + if (startpit == endpit) + return pars[startpit].asString(buffer, startpos, endpos, label); - // This is annoying as one has to press far too often. - // Disable it. + // First paragraph in selection + string result = pars[startpit]. + asString(buffer, startpos, pars[startpit].size(), label) + "\n\n"; - if (0) { - // leave autocorrect mode if necessary - if (autocorrect() && c == ' ') { - autocorrect() = false; - return true; + // The paragraphs in between (if any) + for (pit_type pit = startpit + 1; pit != endpit; ++pit) { + Paragraph & par = pars[pit]; + result += par.asString(buffer, 0, par.size(), label) + "\n\n"; } - } - - // just clear selection on pressing the space bar - if (selection() && c == ' ') { - selection() = false; - return true; - } - - selClearOrDel(); - - if (c == '\\') { - //lyxerr << "starting with macro" << endl; - insert(MathAtom(new MathUnknownInset("\\", false))); - return true; - } - - if (c == '\n') { - if (currentMode() == MathInset::TEXT_MODE) - insert(c); - return true; - } - if (c == ' ') { - if (currentMode() == MathInset::TEXT_MODE) { - // insert spaces in text mode, - // but suppress direct insertion of two spaces in a row - // the still allows typing 'a' and deleting the 'a', but - // it is better than nothing... - if (!pos() != 0 || prevAtom()->getChar() != ' ') - insert(c); - return true; - } - if (pos() != 0 && prevAtom()->asSpaceInset()) { - prevAtom().nucleus()->asSpaceInset()->incSpace(); - return true; - } - if (popRight()) - return true; - // if are at the very end, leave the formula - return pos() != lastpos(); - } + // Last paragraph in selection + result += pars[endpit].asString(buffer, 0, endpos, label); - if (c == '_') { - script(false); - return true; + return result; } - if (c == '^') { - script(true); - return true; - } +#ifdef WITH_WARNINGS +#warning and mathed? +#endif + return string(); +} - if (c == '{' || c == '}' || c == '#' || c == '&' || c == '$') { - niceInsert(createMathInset(string(1, c))); - return true; - } - if (c == '%') { - niceInsert(MathAtom(new MathCommentInset)); - return true; +string LCursor::currentState() +{ + if (inMathed()) { + std::ostringstream os; + info(os); + return os.str(); } - // try auto-correction - //if (autocorrect() && hasPrevAtom() && math_autocorrect(prevAtom(), c)) - // return true; + if (inTexted()) + return text()->currentState(*this); - // no special circumstances, so insert the character without any fuss - insert(c); - autocorrect() = true; - return true; + return string(); } -void LCursor::lockToggle() +string LCursor::getPossibleLabel() { - if (pos() != lastpos()) { - // toggle previous inset ... - nextAtom().nucleus()->lock(!nextAtom()->lock()); - } else if (popLeft() && pos() != lastpos()) { - // ... or enclosing inset if we are in the last inset position - nextAtom().nucleus()->lock(!nextAtom()->lock()); - posRight(); - } + return inMathed() ? "eq:" : text()->getPossibleLabel(*this); } -CursorSlice LCursor::normalAnchor() +Encoding const * LCursor::getEncoding() const { - if (anchor_.size() < depth()) { - resetAnchor(); - lyxerr << "unusual Anchor size" << endl; - } - //lyx::BOOST_ASSERT(Anchor_.size() >= cursor.depth()); - // use Anchor on the same level as Cursor - CursorSlice normal = anchor_[current_]; -#if 0 - if (depth() < anchor_.size() && !(normal < xx())) { - // anchor is behind cursor -> move anchor behind the inset - ++normal.pos_; - } -#endif - return normal; + if (empty()) + return 0; + if (!bv().buffer()) + return 0; + 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.language()->encoding(); } -/* -DispatchResult dispatch(LCursor & cur, FuncRequest const & cmd) -{ - // mouse clicks are somewhat special - // check - switch (cmd.action) { - case LFUN_MOUSE_PRESS: - case LFUN_MOUSE_MOTION: - case LFUN_MOUSE_RELEASE: - case LFUN_MOUSE_DOUBLE: { - CursorSlice & pos = cursor_.back(); - int x = 0; - int y = 0; - getPos(x, y); - if (x < cmd.x && pos() != 0) { - DispatchResult const res = prevAtom().nucleus()->dispatch(cmd); - if (res.dispatched()) - return res; - } - if (x > cmd.x && pos() != lastpos()) { - DispatchResult const res = inset()->dispatch(cmd); - if (res.dispatched()) - return res; - } - } - default: - break; - } +void LCursor::undispatched() +{ + disp_.dispatched(false); } -*/ -void LCursor::handleFont(string const & font) +void LCursor::dispatched() { - string safe; - if (selection()) { - macroModeClose(); - safe = grabAndEraseSelection(); - } - - if (lastpos() != 0) { - // something left in the cell - if (pos() == 0) { - // cursor in first position - popLeft(); - } else if (pos() == lastpos()) { - // cursor in last position - popRight(); - } else { - // cursor in between. split cell - MathArray::iterator bt = cell().begin(); - MathAtom at = createMathInset(font); - at.nucleus()->cell(0) = MathArray(bt, bt + pos()); - cell().erase(bt, bt + pos()); - popLeft(); - plainInsert(at); - } - } else { - // nothing left in the cell - pullArg(); - plainErase(); - } - insert(safe); + disp_.dispatched(true); } -void LCursor::releaseMathCursor() +void LCursor::needsUpdate() { - if (inMathed()) - formula()->insetUnlock(bv()); + disp_.update(true); } -bool LCursor::inMathed() const +void LCursor::noUpdate() { - return formula(); + disp_.update(false); } -InsetBase * LCursor::nextInset() +LyXFont LCursor::getFont() const { - if (pos() == lastpos()) - return 0; - if (inMathed()) - return nextAtom().nucleus(); - Paragraph & par = paragraph(); - return par.isInset(pos()) ? par.getInset(pos()) : 0; + // 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; } -InsetBase * LCursor::prevInset() +void LCursor::fixIfBroken() { - if (pos() == 0) - return 0; - if (inMathed()) - return prevAtom().nucleus(); - Paragraph & par = paragraph(); - return par.isInset(pos() - 1) ? par.getInset(pos() - 1) : 0; + // 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; + } } -