X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathNest.cpp;h=392e1ff8e8c389f27f0c31ed6495e160dfc2b034;hb=66fa801e74e1775b31008df548332436ce79e2e1;hp=d8c83652798ff1ed45ea172773c38dafaf8b70cb;hpb=dbbf47ab14e5eaa2a504acbbfb4bd55e86191805;p=lyx.git diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp index d8c8365279..392e1ff8e8 100644 --- a/src/mathed/InsetMathNest.cpp +++ b/src/mathed/InsetMathNest.cpp @@ -3,7 +3,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ @@ -13,19 +13,23 @@ #include "InsetMathNest.h" #include "InsetMathArray.h" +#include "InsetMathAMSArray.h" #include "InsetMathBig.h" #include "InsetMathBox.h" #include "InsetMathBrace.h" +#include "InsetMathChar.h" #include "InsetMathColor.h" #include "InsetMathComment.h" #include "InsetMathDelim.h" +#include "InsetMathEnsureMath.h" #include "InsetMathHull.h" -//#include "InsetMathMBox.h" #include "InsetMathRef.h" #include "InsetMathScript.h" #include "InsetMathSpace.h" #include "InsetMathSymbol.h" #include "InsetMathUnknown.h" +#include "MathAutoCorrect.h" +#include "MathCompletionList.h" #include "MathData.h" #include "MathFactory.h" #include "MathMacro.h" @@ -35,30 +39,38 @@ #include "MathSupport.h" #include "Bidi.h" +#include "Buffer.h" +#include "BufferParams.h" #include "BufferView.h" #include "CoordCache.h" #include "Cursor.h" #include "CutAndPaste.h" -#include "debug.h" #include "DispatchResult.h" +#include "Encoding.h" #include "FuncRequest.h" #include "FuncStatus.h" -#include "LyXFunc.h" -#include "gettext.h" -#include "Text.h" +#include "LyX.h" +#include "LyXRC.h" #include "OutputParams.h" +#include "Text.h" -#include "support/lstrings.h" -#include "support/textutils.h" - +#include "frontends/Application.h" #include "frontends/Clipboard.h" #include "frontends/Painter.h" #include "frontends/Selection.h" -#include "FuncRequest.h" +#include "support/lassert.h" +#include "support/debug.h" +#include "support/gettext.h" +#include "support/lstrings.h" +#include "support/textutils.h" +#include "support/docstream.h" +#include #include +using namespace std; +using namespace lyx::support; namespace lyx { @@ -68,32 +80,50 @@ using cap::cutSelection; using cap::replaceSelection; using cap::selClearOrDel; -using std::endl; -using std::string; -using std::istringstream; - -InsetMathNest::InsetMathNest(idx_type nargs) - : cells_(nargs), lock_(false), mouse_hover_(false) -{} +InsetMathNest::InsetMathNest(Buffer * buf, idx_type nargs) + : InsetMath(buf), cells_(nargs), lock_(false) +{ + setBuffer(*buf); +} InsetMathNest::InsetMathNest(InsetMathNest const & inset) - : InsetMath(inset), cells_(inset.cells_), lock_(inset.lock_), - mouse_hover_(false) + : InsetMath(inset), cells_(inset.cells_), lock_(inset.lock_) {} +InsetMathNest::~InsetMathNest() +{ + map::iterator it = mouse_hover_.begin(); + map::iterator end = mouse_hover_.end(); + for (; it != end; ++it) + if (it->second) + it->first->clearLastInset(this); +} + + InsetMathNest & InsetMathNest::operator=(InsetMathNest const & inset) { cells_ = inset.cells_; lock_ = inset.lock_; - mouse_hover_ = false; + mouse_hover_.clear(); InsetMath::operator=(inset); return *this; } +void InsetMathNest::setBuffer(Buffer & buffer) +{ + InsetMath::setBuffer(buffer); + for (idx_type i = 0, n = nargs(); i != n; ++i) { + MathData & data = cell(i); + for (size_t j = 0; j != data.size(); ++j) + data[j].nucleus()->setBuffer(buffer); + } +} + + InsetMath::idx_type InsetMathNest::nargs() const { return cells_.size(); @@ -111,7 +141,7 @@ void InsetMathNest::cursorPos(BufferView const & bv, // to touch all (math)inset's draw() methods. Right now, we'll store // absolute value, and make them here relative, only to make them // absolute again when actually drawing the cursor. What a mess. - BOOST_ASSERT(ptr_cmp(&sl.inset(), this)); + LASSERT(&sl.inset() == this, return); MathData const & ar = sl.cell(); CoordCache const & coord_cache = bv.coordCache(); if (!coord_cache.getArrays().has(&ar)) { @@ -132,8 +162,8 @@ void InsetMathNest::cursorPos(BufferView const & bv, } Point const pt2 = coord_cache.getInsets().xy(this); //lyxerr << "retrieving position cache for MathData " - // << pt.x_ << ' ' << pt.y_ << std::endl; - x = pt.x_ - pt2.x_ + ar.pos2x(sl.pos()); + // << pt.x_ << ' ' << pt.y_ << endl; + x = pt.x_ - pt2.x_ + ar.pos2x(&bv, sl.pos()); y = pt.y_ - pt2.y_; // lyxerr << "pt.y_ : " << pt.y_ << " pt2_.y_ : " << pt2.y_ // << " asc: " << ascent() << " des: " << descent() @@ -154,9 +184,17 @@ void InsetMathNest::metrics(MetricsInfo const & mi) const } +void InsetMathNest::updateBuffer(ParIterator const & it, UpdateType utype) +{ + for (idx_type i = 0, n = nargs(); i != n; ++i) + cell(i).updateBuffer(it, utype); +} + + + bool InsetMathNest::idxNext(Cursor & cur) const { - BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); + LASSERT(&cur.inset() == this, return false); if (cur.idx() == cur.lastidx()) return false; ++cur.idx(); @@ -165,7 +203,7 @@ bool InsetMathNest::idxNext(Cursor & cur) const } -bool InsetMathNest::idxRight(Cursor & cur) const +bool InsetMathNest::idxForward(Cursor & cur) const { return idxNext(cur); } @@ -173,7 +211,7 @@ bool InsetMathNest::idxRight(Cursor & cur) const bool InsetMathNest::idxPrev(Cursor & cur) const { - BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); + LASSERT(&cur.inset() == this, return false); if (cur.idx() == 0) return false; --cur.idx(); @@ -182,7 +220,7 @@ bool InsetMathNest::idxPrev(Cursor & cur) const } -bool InsetMathNest::idxLeft(Cursor & cur) const +bool InsetMathNest::idxBackward(Cursor & cur) const { return idxPrev(cur); } @@ -190,7 +228,7 @@ bool InsetMathNest::idxLeft(Cursor & cur) const bool InsetMathNest::idxFirst(Cursor & cur) const { - BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); + LASSERT(&cur.inset() == this, return false); if (nargs() == 0) return false; cur.idx() = 0; @@ -201,7 +239,7 @@ bool InsetMathNest::idxFirst(Cursor & cur) const bool InsetMathNest::idxLast(Cursor & cur) const { - BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); + LASSERT(&cur.inset() == this, return false); if (nargs() == 0) return false; cur.idx() = cur.lastidx(); @@ -242,13 +280,14 @@ void InsetMathNest::drawSelection(PainterInfo & pi, int x, int y) const Cursor & cur = bv.cursor(); if (!cur.selection()) return; - if (!ptr_cmp(&cur.inset(), this)) + if (&cur.inset() != this) return; // FIXME: hack to get position cache warm + bool const original_drawing_state = pi.pain.isDrawingEnabled(); pi.pain.setDrawingEnabled(false); draw(pi, x, y); - pi.pain.setDrawingEnabled(true); + pi.pain.setDrawingEnabled(original_drawing_state); CursorSlice s1 = cur.selBegin(); CursorSlice s2 = cur.selEnd(); @@ -258,9 +297,9 @@ void InsetMathNest::drawSelection(PainterInfo & pi, int x, int y) const if (s1.idx() == s2.idx()) { MathData const & c = cell(s1.idx()); Geometry const & g = bv.coordCache().getArrays().geometry(&c); - int x1 = g.pos.x_ + c.pos2x(s1.pos()); + int x1 = g.pos.x_ + c.pos2x(pi.base.bv, s1.pos()); int y1 = g.pos.y_ - g.dim.ascent(); - int x2 = g.pos.x_ + c.pos2x(s2.pos()); + int x2 = g.pos.x_ + c.pos2x(pi.base.bv, s2.pos()); int y2 = g.pos.y_ + g.dim.descent(); pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, Color_selection); //lyxerr << "InsetMathNest::drawing selection 3: " @@ -334,7 +373,10 @@ MathData InsetMathNest::glue() const void InsetMathNest::write(WriteStream & os) const { - os << '\\' << name().c_str(); + MathEnsurer ensurer(os, currentMode() == MATH_MODE); + ModeSpecifier specifier(os, currentMode(), lockedMode()); + docstring const latex_name = name(); + os << '\\' << latex_name; for (size_t i = 0; i < nargs(); ++i) os << '{' << cell(i) << '}'; if (nargs() == 0) @@ -348,30 +390,43 @@ void InsetMathNest::write(WriteStream & os) const void InsetMathNest::normalize(NormalStream & os) const { - os << '[' << name().c_str(); + os << '[' << name(); for (size_t i = 0; i < nargs(); ++i) os << ' ' << cell(i); os << ']'; } -int InsetMathNest::latex(Buffer const &, odocstream & os, - OutputParams const & runparams) const +void InsetMathNest::latex(otexstream & os, OutputParams const & runparams) const { - WriteStream wi(os, runparams.moving_arg, true); + WriteStream wi(os.os(), runparams.moving_arg, true, + runparams.dryrun ? WriteStream::wsDryrun : WriteStream::wsDefault, + runparams.encoding); + wi.canBreakLine(os.canBreakLine()); write(wi); - return wi.line(); + // Reset parbreak status after a math inset. + os.lastChar(0); + os.canBreakLine(wi.canBreakLine()); + + int lf = wi.line(); + if (lf > 0 && runparams.lastid != -1) { + --lf; + os.texrow().newline(); + os.texrow().start(runparams.lastid, runparams.lastpos); + } + os.texrow().newlines(lf); } -bool InsetMathNest::setMouseHover(bool mouse_hover) +bool InsetMathNest::setMouseHover(BufferView const * bv, bool mouse_hover) + const { - mouse_hover_ = mouse_hover; + mouse_hover_[bv] = mouse_hover; return true; } -bool InsetMathNest::notifyCursorLeaves(Cursor & /*cur*/) +bool InsetMathNest::notifyCursorLeaves(Cursor const & /*old*/, Cursor & /*cur*/) { // FIXME: look here #if 0 @@ -409,58 +464,132 @@ void InsetMathNest::handleFont } -void InsetMathNest::handleFont - (Cursor & cur, docstring const & arg, docstring const & font) +void InsetMathNest::handleFont(Cursor & cur, docstring const & arg, + docstring const & font) { + cur.recordUndoSelection(); + // this whole function is a hack and won't work for incremental font // changes... - - if (cur.inset().asInsetMath()->name() == font) { - cur.recordUndoInset(); + if (cur.inset().asInsetMath()->name() == font) cur.handleFont(to_utf8(font)); - } else { - cur.recordUndo(); - cur.handleNest(createInsetMath(font)); + else + handleNest(cur, createInsetMath(font, cur.buffer()), arg); +} + + +void InsetMathNest::handleNest(Cursor & cur, MathAtom const & nest) +{ + handleNest(cur, nest, docstring()); +} + + +void InsetMathNest::handleNest(Cursor & cur, MathAtom const & nest, + docstring const & arg) +{ + CursorSlice i1 = cur.selBegin(); + CursorSlice i2 = cur.selEnd(); + if (!i1.inset().asInsetMath()) + return; + if (i1.idx() == i2.idx()) { + // the easy case where only one cell is selected + cur.handleNest(nest); cur.insert(arg); + return; + } + + // multiple selected cells in a simple non-grid inset + if (i1.asInsetMath()->nrows() == 0 || i1.asInsetMath()->ncols() == 0) { + for (idx_type i = i1.idx(); i <= i2.idx(); ++i) { + // select cell + cur.idx() = i; + cur.pos() = 0; + cur.resetAnchor(); + cur.pos() = cur.lastpos(); + cur.setSelection(); + + // change font of cell + cur.handleNest(nest); + cur.insert(arg); + + // cur is in the font inset now. If the loop continues, + // we need to get outside again for the next cell + if (i + 1 <= i2.idx()) + cur.pop_back(); + } + return; + } + + // the complicated case with multiple selected cells in a grid + row_type r1, r2; + col_type c1, c2; + cap::region(i1, i2, r1, r2, c1, c2); + for (row_type row = r1; row <= r2; ++row) { + for (col_type col = c1; col <= c2; ++col) { + // select cell + cur.idx() = i1.asInsetMath()->index(row, col); + cur.pos() = 0; + cur.resetAnchor(); + cur.pos() = cur.lastpos(); + cur.setSelection(); + + // + cur.handleNest(nest); + cur.insert(arg); + + // cur is in the font inset now. If the loop continues, + // we need to get outside again for the next cell + if (col + 1 <= c2 || row + 1 <= r2) + cur.pop_back(); + } } } void InsetMathNest::handleFont2(Cursor & cur, docstring const & arg) { - cur.recordUndo(); + cur.recordUndoSelection(); Font font; bool b; font.fromString(to_utf8(arg), b); - if (font.fontInfo().color() != Color_inherit) { - MathAtom at = MathAtom(new InsetMathColor(true, font.fontInfo().color())); - cur.handleNest(at, 0); - } + if (font.fontInfo().color() != Color_inherit && + font.fontInfo().color() != Color_ignore) + handleNest(cur, MathAtom(new InsetMathColor(buffer_, true, font.fontInfo().color()))); + + // FIXME: support other font changes here as well? } void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) { - //lyxerr << "InsetMathNest: request: " << cmd << std::endl; - //CursorSlice sl = cur.current(); + //LYXERR0("InsetMathNest: request: " << cmd); - switch (cmd.action) { + Parse::flags parseflg = Parse::QUIET | Parse::USETEXT; + FuncCode const act = cmd.action(); + switch (act) { + + case LFUN_CLIPBOARD_PASTE: + parseflg |= Parse::VERBATIM; + // fall through case LFUN_PASTE: { - cur.recordUndo(); + if (cur.currentMode() <= TEXT_MODE) + parseflg |= Parse::TEXTMODE; + cur.recordUndoSelection(); cur.message(_("Paste")); replaceSelection(cur); docstring topaste; if (cmd.argument().empty() && !theClipboard().isInternal()) - topaste = theClipboard().getAsText(); + topaste = theClipboard().getAsText(Clipboard::PlainTextType); else { size_t n = 0; idocstringstream is(cmd.argument()); is >> n; - topaste = cap::getSelection(cur.buffer(), n); + topaste = cap::selection(n, buffer().params().documentClassPtr()); } - cur.niceInsert(topaste); + cur.niceInsert(topaste, parseflg, false); cur.clearSelection(); // bug 393 + cur.forceBufferUpdate(); cur.finishUndo(); break; } @@ -472,6 +601,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) // Prevent stale position >= size crash // Probably not necessary anymore, see eraseSelection (gb 2005-10-09) cur.normalize(); + cur.forceBufferUpdate(); break; case LFUN_COPY: @@ -491,83 +621,82 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) lfunMouseRelease(cur, cmd); break; + case LFUN_FINISHED_LEFT: // in math, left is backwards case LFUN_FINISHED_BACKWARD: cur.bv().cursor() = cur; break; + case LFUN_FINISHED_RIGHT: // in math, right is forward case LFUN_FINISHED_FORWARD: ++cur.pos(); cur.bv().cursor() = cur; break; + case LFUN_CHAR_RIGHT: + case LFUN_CHAR_LEFT: + case LFUN_CHAR_BACKWARD: case LFUN_CHAR_FORWARD: - cur.updateFlags(Update::Decoration | Update::FitCursor); - case LFUN_CHAR_FORWARD_SELECT: - cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); - cur.autocorrect() = false; - cur.clearTargetX(); - cur.macroModeClose(); - if (cur.pos() != cur.lastpos() && cur.openable(cur.nextAtom())) { - cur.pushLeft(*cur.nextAtom().nucleus()); - cur.inset().idxFirst(cur); - } else if (cur.posRight() || idxRight(cur) - || cur.popRight() || cur.selection()) - ; - else { - cmd = FuncRequest(LFUN_FINISHED_FORWARD); - cur.undispatched(); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); + case LFUN_CHAR_RIGHT_SELECT: + case LFUN_CHAR_LEFT_SELECT: + case LFUN_CHAR_BACKWARD_SELECT: + case LFUN_CHAR_FORWARD_SELECT: { + // are we in a selection? + bool select = (act == LFUN_CHAR_RIGHT_SELECT + || act == LFUN_CHAR_LEFT_SELECT + || act == LFUN_CHAR_BACKWARD_SELECT + || act == LFUN_CHAR_FORWARD_SELECT); + // are we moving forward or backwards? + // If the command was RIGHT or LEFT, then whether we're moving forward + // or backwards depends on the cursor movement mode (logical or visual): + // * in visual mode, since math is always LTR, right -> forward, + // left -> backwards + // * in logical mode, the mapping is determined by the + // reverseDirectionNeeded() function + + bool forward; + FuncCode finish_lfun; + + if (act == LFUN_CHAR_FORWARD + || act == LFUN_CHAR_FORWARD_SELECT) { + forward = true; + finish_lfun = LFUN_FINISHED_FORWARD; } - break; + else if (act == LFUN_CHAR_BACKWARD + || act == LFUN_CHAR_BACKWARD_SELECT) { + forward = false; + finish_lfun = LFUN_FINISHED_BACKWARD; + } + else { + bool right = (act == LFUN_CHAR_RIGHT_SELECT + || act == LFUN_CHAR_RIGHT); + if (lyxrc.visual_cursor || !reverseDirectionNeeded(cur)) + forward = right; + else + forward = !right; - case LFUN_CHAR_BACKWARD: - cur.updateFlags(Update::Decoration | Update::FitCursor); - case LFUN_CHAR_BACKWARD_SELECT: - cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); - cur.autocorrect() = false; + if (right) + finish_lfun = LFUN_FINISHED_RIGHT; + else + finish_lfun = LFUN_FINISHED_LEFT; + } + // Now that we know exactly what we want to do, let's do it! + cur.selHandle(select); cur.clearTargetX(); cur.macroModeClose(); - if (cur.pos() != 0 && cur.openable(cur.prevAtom())) { - cur.posLeft(); - cur.push(*cur.nextAtom().nucleus()); - cur.inset().idxLast(cur); - } else if (cur.posLeft() || idxLeft(cur) - || cur.popLeft() || cur.selection()) - ; - else { - cmd = FuncRequest(LFUN_FINISHED_BACKWARD); + // try moving forward or backwards as necessary... + if (!(forward ? cursorMathForward(cur) : cursorMathBackward(cur))) { + // ... and if movement failed, then finish forward or backwards + // as necessary + cmd = FuncRequest(finish_lfun); cur.undispatched(); } break; - - case LFUN_CHAR_RIGHT: - case LFUN_CHAR_RIGHT_SELECT: - //FIXME: for visual cursor, really move right - if (reverseDirectionNeeded(cur)) - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD)); - else - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD)); - break; - - case LFUN_CHAR_LEFT: - case LFUN_CHAR_LEFT_SELECT: - //FIXME: for visual cursor, really move left - if (reverseDirectionNeeded(cur)) - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD)); - else - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD)); - break; + } case LFUN_DOWN: case LFUN_UP: - cur.updateFlags(Update::Decoration | Update::FitCursor); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); case LFUN_DOWN_SELECT: case LFUN_UP_SELECT: { // close active macro @@ -575,22 +704,22 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.macroModeClose(); break; } - + // stop/start the selection - bool select = cmd.action == LFUN_DOWN_SELECT || - cmd.action == LFUN_UP_SELECT; + bool select = act == LFUN_DOWN_SELECT || + act == LFUN_UP_SELECT; cur.selHandle(select); - + + // handle autocorrect: + cur.autocorrect() = false; + cur.message(_("Autocorrect Off ('!' to enter)")); + // go up/down - bool up = cmd.action == LFUN_UP || cmd.action == LFUN_UP_SELECT; + bool up = act == LFUN_UP || act == LFUN_UP_SELECT; bool successful = cur.upDownInMath(up); - if (successful) { - // notify left insets and give them chance to set update flags - lyx::notifyCursorLeaves(cur.beforeDispatchCursor(), cur); - cur.fixIfBroken(); + if (successful) break; - } - + if (cur.fixIfBroken()) // FIXME: Something bad happened. We pass the corrected Cursor // instead of letting things go worse. @@ -607,14 +736,15 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.pos() = 0; cur.idx() = 0; cur.resetAnchor(); - cur.selection() = true; - cur.pos() = cur.lastpos(); + cur.setSelection(true); cur.idx() = cur.lastidx(); + cur.pos() = cur.lastpos(); + cur.bv().cursor() = cur; break; case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_DOWN: - cur.updateFlags(Update::Decoration | Update::FitCursor); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); case LFUN_PARAGRAPH_UP_SELECT: case LFUN_PARAGRAPH_DOWN_SELECT: break; @@ -622,13 +752,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_LINE_BEGIN: case LFUN_WORD_BACKWARD: case LFUN_WORD_LEFT: - cur.updateFlags(Update::Decoration | Update::FitCursor); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); case LFUN_LINE_BEGIN_SELECT: case LFUN_WORD_BACKWARD_SELECT: case LFUN_WORD_LEFT_SELECT: - cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT || - cmd.action == LFUN_WORD_LEFT_SELECT || - cmd.action == LFUN_LINE_BEGIN_SELECT); + cur.selHandle(act == LFUN_WORD_BACKWARD_SELECT || + act == LFUN_WORD_LEFT_SELECT || + act == LFUN_LINE_BEGIN_SELECT); cur.macroModeClose(); if (cur.pos() != 0) { cur.pos() = 0; @@ -647,13 +777,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_FORWARD: case LFUN_WORD_RIGHT: case LFUN_LINE_END: - cur.updateFlags(Update::Decoration | Update::FitCursor); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); case LFUN_WORD_FORWARD_SELECT: case LFUN_WORD_RIGHT_SELECT: case LFUN_LINE_END_SELECT: - cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT || - cmd.action == LFUN_WORD_RIGHT_SELECT || - cmd.action == LFUN_LINE_END_SELECT); + cur.selHandle(act == LFUN_WORD_FORWARD_SELECT || + act == LFUN_WORD_RIGHT_SELECT || + act == LFUN_LINE_END_SELECT); cur.macroModeClose(); cur.clearTargetX(); if (cur.pos() != cur.lastpos()) { @@ -670,23 +800,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } break; - case LFUN_SCREEN_UP_SELECT: - cmd = FuncRequest(LFUN_FINISHED_BACKWARD); - cur.undispatched(); - break; - - case LFUN_SCREEN_DOWN_SELECT: - cmd = FuncRequest(LFUN_FINISHED_FORWARD); - cur.undispatched(); - break; - case LFUN_CELL_FORWARD: - cur.updateFlags(Update::Decoration | Update::FitCursor); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); cur.inset().idxNext(cur); break; case LFUN_CELL_BACKWARD: - cur.updateFlags(Update::Decoration | Update::FitCursor); + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); cur.inset().idxPrev(cur); break; @@ -695,8 +815,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (cur.pos() == 0) // May affect external cell: cur.recordUndoInset(); - else - cur.recordUndo(); + else if (!cur.inMacroMode()) + cur.recordUndoSelection(); // if the inset can not be removed from within, delete it if (!cur.backspace()) { FuncRequest cmd = FuncRequest(LFUN_CHAR_DELETE_FORWARD); @@ -710,7 +830,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) // May affect external cell: cur.recordUndoInset(); else - cur.recordUndo(); + cur.recordUndoSelection(); // if the inset can not be removed from within, delete it if (!cur.erase()) { FuncRequest cmd = FuncRequest(LFUN_CHAR_DELETE_FORWARD); @@ -727,21 +847,23 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } break; + // 'Locks' the math inset. A 'locked' math inset behaves as a unit + // that is traversed by a single /. case LFUN_INSET_TOGGLE: cur.recordUndo(); lock(!lock()); - cur.popRight(); + cur.popForward(); break; case LFUN_SELF_INSERT: if (cmd.argument().size() != 1) { - cur.recordUndo(); + cur.recordUndoSelection(); docstring const arg = cmd.argument(); if (!interpretString(cur, arg)) cur.insert(arg); break; } - // Don't record undo steps if we are in macro mode and + // Don't record undo steps if we are in macro mode and thus // cmd.argument is the next character of the macro name. // Otherwise we'll get an invalid cursor if we undo after // the macro was finished and the macro is a known command, @@ -750,19 +872,20 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) // InsetMathFrac -> a pos value > 0 is invalid. // A side effect is that an undo before the macro is finished // undoes the complete macro, not only the last character. + // At the time we hit '\' we are not in macro mode, still. if (!cur.inMacroMode()) - cur.recordUndo(); + cur.recordUndoSelection(); // spacial handling of space. If we insert an inset // via macro mode, we want to put the cursor inside it // if relevant. Think typing "\frac". if (cmd.argument()[0] == ' ' && cur.inMacroMode() && cur.macroName() != "\\" - && cur.macroModeClose()) { + && cur.macroModeClose() && cur.pos() > 0) { MathAtom const atom = cur.prevAtom(); if (atom->asNestInset() && atom->isActive()) { - cur.posLeft(); - cur.pushLeft(*cur.nextInset()); + cur.posBackward(); + cur.pushBackward(*cur.nextInset()); } } else if (!interpretChar(cur, cmd.argument()[0])) { cmd = FuncRequest(LFUN_FINISHED_FORWARD); @@ -771,7 +894,6 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) break; //case LFUN_SERVER_GET_XY: - // sprintf(dispatch_buffer, "%d %d",); // break; case LFUN_SERVER_SET_XY: { @@ -790,7 +912,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (cmd.argument().empty()) { // do superscript if LyX handles // deadkeys - cur.recordUndo(); + cur.recordUndoSelection(); script(cur, true, grabAndEraseSelection(cur)); } break; @@ -812,37 +934,43 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) break; // Math fonts - case LFUN_FONT_FREE_APPLY: - case LFUN_FONT_FREE_UPDATE: + case LFUN_TEXTSTYLE_APPLY: + case LFUN_TEXTSTYLE_UPDATE: handleFont2(cur, cmd.argument()); break; case LFUN_FONT_BOLD: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) handleFont(cur, cmd.argument(), "textbf"); else handleFont(cur, cmd.argument(), "mathbf"); break; + case LFUN_FONT_BOLDSYMBOL: + if (currentMode() <= TEXT_MODE) + handleFont(cur, cmd.argument(), "textbf"); + else + handleFont(cur, cmd.argument(), "boldsymbol"); + break; case LFUN_FONT_SANS: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) handleFont(cur, cmd.argument(), "textsf"); else handleFont(cur, cmd.argument(), "mathsf"); break; case LFUN_FONT_EMPH: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) handleFont(cur, cmd.argument(), "emph"); else handleFont(cur, cmd.argument(), "mathcal"); break; case LFUN_FONT_ROMAN: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) handleFont(cur, cmd.argument(), "textrm"); else handleFont(cur, cmd.argument(), "mathrm"); break; case LFUN_FONT_TYPEWRITER: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) handleFont(cur, cmd.argument(), "texttt"); else handleFont(cur, cmd.argument(), "mathtt"); @@ -851,43 +979,47 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) handleFont(cur, cmd.argument(), "mathfrak"); break; case LFUN_FONT_ITAL: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) handleFont(cur, cmd.argument(), "textit"); else handleFont(cur, cmd.argument(), "mathit"); break; case LFUN_FONT_NOUN: - if (currentMode() == TEXT_MODE) + if (currentMode() <= TEXT_MODE) // FIXME: should be "noun" handleFont(cur, cmd.argument(), "textsc"); else handleFont(cur, cmd.argument(), "mathbb"); break; - /* - case LFUN_FONT_FREE_APPLY: - handleFont(cur, cmd.argument(), "textrm"); - break; - */ case LFUN_FONT_DEFAULT: handleFont(cur, cmd.argument(), "textnormal"); break; + case LFUN_FONT_UNDERLINE: + cur.recordUndo(); + cur.handleNest(createInsetMath("underline", cur.buffer())); + break; case LFUN_MATH_MODE: { #if 1 // ignore math-mode on when already in math mode if (currentMode() == Inset::MATH_MODE && cmd.argument() == "on") break; + cur.recordUndoSelection(); cur.macroModeClose(); docstring const save_selection = grabAndEraseSelection(cur); selClearOrDel(cur); - //cur.plainInsert(MathAtom(new InsetMathMBox(cur.bv()))); - cur.plainInsert(MathAtom(new InsetMathBox(from_ascii("mbox")))); - cur.posLeft(); - cur.pushLeft(*cur.nextInset()); + if (currentMode() <= Inset::TEXT_MODE) + cur.plainInsert(MathAtom(new InsetMathEnsureMath(buffer_))); + else + cur.plainInsert(MathAtom(new InsetMathBox(buffer_, from_ascii("mbox")))); + cur.posBackward(); + cur.pushBackward(*cur.nextInset()); cur.niceInsert(save_selection); + cur.forceBufferUpdate(); #else if (currentMode() == Inset::TEXT_MODE) { - cur.niceInsert(MathAtom(new InsetMathHull("simple"))); + cur.recordUndoSelection(); + cur.niceInsert(MathAtom(new InsetMathHull("simple", cur.buffer()))); cur.message(_("create new math text environment ($...$)")); } else { handleFont(cur, cmd.argument(), "textrm"); @@ -897,12 +1029,37 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_MATH_SIZE: -#if 0 - cur.recordUndo(); - cur.setSize(arg); -#endif + case LFUN_REGEXP_MODE: { + InsetMath * im = cur.inset().asInsetMath(); + if (im) { + InsetMathHull * i = im->asHullInset(); + if (i && i->getType() == hullRegexp) { + cur.message(_("Already in regular expression mode")); + break; + } + } + cur.macroModeClose(); + docstring const save_selection = grabAndEraseSelection(cur); + selClearOrDel(cur); + cur.plainInsert(MathAtom(new InsetMathHull(buffer_, hullRegexp))); + cur.posBackward(); + cur.pushBackward(*cur.nextInset()); + cur.niceInsert(save_selection); + cur.message(_("Regular expression editor mode")); break; + } + + case LFUN_MATH_FONT_STYLE: { + FuncRequest fr = FuncRequest(LFUN_MATH_INSERT, '\\' + cmd.argument()); + doDispatch(cur, fr); + break; + } + + case LFUN_MATH_SIZE: { + FuncRequest fr = FuncRequest(LFUN_MATH_INSERT, cmd.argument()); + doDispatch(cur, fr); + break; + } case LFUN_MATH_MATRIX: { cur.recordUndo(); @@ -917,21 +1074,43 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (n < 1) n = 1; v_align += 'c'; + cur.niceInsert(MathAtom(new InsetMathArray(buffer_, + from_ascii("array"), m, n, (char)v_align[0], h_align))); + break; + } + + case LFUN_MATH_AMS_MATRIX: { + cur.recordUndo(); + unsigned int m = 1; + unsigned int n = 1; + docstring name = from_ascii("matrix"); + idocstringstream is(cmd.argument()); + is >> m >> n >> name; + if (m < 1) + m = 1; + if (n < 1) + n = 1; + // check if we have a valid decoration + if (name != "pmatrix" && name != "bmatrix" + && name != "Bmatrix" && name != "vmatrix" + && name != "Vmatrix" && name != "matrix") + name = from_ascii("matrix"); + cur.niceInsert( - MathAtom(new InsetMathArray(from_ascii("array"), m, n, (char)v_align[0], h_align))); + MathAtom(new InsetMathAMSArray(buffer_, name, m, n))); break; } case LFUN_MATH_DELIM: { docstring ls; - docstring rs = support::split(cmd.argument(), ls, ' '); + docstring rs = split(cmd.argument(), ls, ' '); // Reasonable default values if (ls.empty()) ls = '('; if (rs.empty()) rs = ')'; cur.recordUndo(); - cur.handleNest(MathAtom(new InsetMathDelim(ls, rs))); + cur.handleNest(MathAtom(new InsetMathDelim(buffer_, ls, rs))); break; } @@ -955,20 +1134,58 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (have_l) cur.insert(MathAtom(new InsetMathBig(lname, ldelim))); - cur.niceInsert(selection); - if (have_r) + // first insert the right delimiter and then go back + // and re-insert the selection (bug 7088) + if (have_r) { cur.insert(MathAtom(new InsetMathBig(rname, rdelim))); + cur.posBackward(); + } + cur.niceInsert(selection); } // Don't call cur.undispatched() if we did nothing, this would // lead to infinite recursion via Text::dispatch(). break; } - case LFUN_SPACE_INSERT: + case LFUN_SPACE_INSERT: { + cur.recordUndoSelection(); + string const name = cmd.getArg(0); + if (name == "normal") + cur.insert(MathAtom(new InsetMathSpace(" ", ""))); + else if (name == "protected") + cur.insert(MathAtom(new InsetMathSpace("~", ""))); + else if (name == "thin" || name == "med" || name == "thick") + cur.insert(MathAtom(new InsetMathSpace(name + "space", ""))); + else if (name == "hfill*") + cur.insert(MathAtom(new InsetMathSpace("hspace*{\\fill}", ""))); + else if (name == "quad" || name == "qquad" || + name == "enspace" || name == "enskip" || + name == "negthinspace" || name == "negmedspace" || + name == "negthickspace" || name == "hfill") + cur.insert(MathAtom(new InsetMathSpace(name, ""))); + else if (name == "hspace" || name == "hspace*") { + string const len = cmd.getArg(1); + if (len.empty() || !isValidLength(len)) { + lyxerr << "LyX function 'space-insert " << name << "' " + "needs a valid length argument." << endl; + break; + } + cur.insert(MathAtom(new InsetMathSpace(name, len))); + } else + cur.insert(MathAtom(new InsetMathSpace)); + break; + } + case LFUN_MATH_SPACE: - cur.recordUndo(); - cur.insert(MathAtom(new InsetMathSpace(from_ascii(",")))); + cur.recordUndoSelection(); + if (cmd.argument().empty()) + cur.insert(MathAtom(new InsetMathSpace)); + else { + string const name = cmd.getArg(0); + string const len = cmd.getArg(1); + cur.insert(MathAtom(new InsetMathSpace(name, len))); + } break; case LFUN_ERT_INSERT: @@ -979,34 +1196,35 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MATH_SUBSCRIPT: // interpret this as if a _ was typed - cur.recordUndo(); + cur.recordUndoSelection(); interpretChar(cur, '_'); break; case LFUN_MATH_SUPERSCRIPT: // interpret this as if a ^ was typed - cur.recordUndo(); + cur.recordUndoSelection(); interpretChar(cur, '^'); break; - + case LFUN_MATH_MACRO_FOLD: case LFUN_MATH_MACRO_UNFOLD: { Cursor it = cur; - bool fold = cmd.action == LFUN_MATH_MACRO_FOLD; + bool fold = act == LFUN_MATH_MACRO_FOLD; bool found = findMacroToFoldUnfold(it, fold); if (found) { - cur.recordUndo(); + MathMacro * macro = it.nextInset()->asInsetMath()->asMacro(); + cur.recordUndoInset(); if (fold) - it.nextInset()->asInsetMath()->asMacro()->fold(cur); + macro->fold(cur); else - it.nextInset()->asInsetMath()->asMacro()->unfold(cur); - } + macro->unfold(cur); + } break; } case LFUN_QUOTE_INSERT: // interpret this as if a straight " was typed - cur.recordUndo(); + cur.recordUndoSelection(); interpretChar(cur, '\"'); break; @@ -1014,30 +1232,57 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) // handling such that "self-insert" works on "arbitrary stuff" too, and // math-insert only handles special math things like "matrix". case LFUN_MATH_INSERT: { - cur.recordUndo(); - if (cmd.argument() == "^" || cmd.argument() == "_") { + cur.recordUndoSelection(); + if (cmd.argument() == "^" || cmd.argument() == "_") interpretChar(cur, cmd.argument()[0]); - } else - cur.niceInsert(cmd.argument()); + else { + MathData ar; + asArray(cmd.argument(), ar); + if (cur.selection() && ar.size() == 1 + && ar[0]->asNestInset() + && ar[0]->asNestInset()->nargs() > 1) + handleNest(cur, ar[0]); + else + cur.niceInsert(cmd.argument()); + } break; + } + + case LFUN_UNICODE_INSERT: { + if (cmd.argument().empty()) + break; + docstring hexstring = cmd.argument(); + if (isHex(hexstring)) { + char_type c = hexToInt(hexstring); + if (c >= 32 && c < 0x10ffff) { + docstring s = docstring(1, c); + FuncCode code = currentMode() == MATH_MODE ? + LFUN_MATH_INSERT : LFUN_SELF_INSERT; + lyx::dispatch(FuncRequest(code, s)); + } } + break; + } case LFUN_DIALOG_SHOW_NEW_INSET: { docstring const & name = cmd.argument(); string data; if (name == "ref") { - InsetMathRef tmp(name); - data = tmp.createDialogStr(to_utf8(name)); + InsetMathRef tmp(buffer_, name); + data = tmp.createDialogStr(); + cur.bv().showDialog(to_utf8(name), data); + } else if (name == "mathspace") { + cur.bv().showDialog(to_utf8(name)); } - cur.bv().showInsetDialog(to_utf8(name), data, 0); break; } case LFUN_INSET_INSERT: { MathData ar; if (createInsetMath_fromDialogStr(cmd.argument(), ar)) { - cur.recordUndo(); + cur.recordUndoSelection(); cur.insert(ar); + cur.forceBufferUpdate(); } else cur.undispatched(); break; @@ -1059,7 +1304,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) bool InsetMathNest::findMacroToFoldUnfold(Cursor & it, bool fold) const { // look for macro to open/close, but stay in mathed for (; !it.empty(); it.pop_back()) { - + // go backward through the current cell Inset * inset = it.nextInset(); while (inset && inset->asInsetMath()) { @@ -1068,21 +1313,24 @@ bool InsetMathNest::findMacroToFoldUnfold(Cursor & it, bool fold) const { // found the an macro to open/close? if (macro->folded() != fold) return true; - - // wrong folding state -> go up one level - break; + + // Wrong folding state. + // If this was the first we see in this slice, look further left, + // otherwise go up. + if (inset != it.nextInset()) + break; } - + // go up if this was the left most position if (it.pos() == 0) break; - + // go left it.pos()--; inset = it.nextInset(); } } - + return false; } @@ -1094,12 +1342,12 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, //string tc = "mathnormal"; bool ret = true; string const arg = to_utf8(cmd.argument()); - switch (cmd.action) { - case LFUN_TABULAR_FEATURE: - flag.enabled(false); + switch (cmd.action()) { + case LFUN_INSET_MODIFY: + flag.setEnabled(false); break; #if 0 - case LFUN_TABULAR_FEATURE: + case LFUN_INSET_MODIFY: // FIXME: check temporarily disabled // valign code char align = mathcursor::valign(); @@ -1121,47 +1369,53 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, /// We have to handle them since 1.4 blocks all unhandled actions case LFUN_FONT_ITAL: case LFUN_FONT_BOLD: + case LFUN_FONT_BOLDSYMBOL: case LFUN_FONT_SANS: case LFUN_FONT_EMPH: case LFUN_FONT_TYPEWRITER: case LFUN_FONT_NOUN: case LFUN_FONT_ROMAN: case LFUN_FONT_DEFAULT: - flag.enabled(true); - break; - case LFUN_MATH_MUTATE: - //flag.setOnOff(mathcursor::formula()->hullType() == to_utf8(cmd.argument())); - flag.setOnOff(false); + flag.setEnabled(true); break; // we just need to be in math mode to enable that case LFUN_MATH_SIZE: case LFUN_MATH_SPACE: - case LFUN_MATH_LIMITS: - case LFUN_MATH_NONUMBER: - case LFUN_MATH_NUMBER: case LFUN_MATH_EXTERN: - flag.enabled(true); + flag.setEnabled(true); break; + case LFUN_FONT_UNDERLINE: case LFUN_FONT_FRAK: - flag.enabled(currentMode() != TEXT_MODE); + flag.setEnabled(currentMode() != TEXT_MODE); break; - case LFUN_MATH_INSERT: { + case LFUN_MATH_FONT_STYLE: { bool const textarg = - arg == "\\textbf" || arg == "\\textsf" || - arg == "\\textrm" || arg == "\\textmd" || - arg == "\\textit" || arg == "\\textsc" || - arg == "\\textsl" || arg == "\\textup" || - arg == "\\texttt" || arg == "\\textbb" || - arg == "\\textnormal"; - flag.enabled(currentMode() != TEXT_MODE || textarg); + arg == "textbf" || arg == "textsf" || + arg == "textrm" || arg == "textmd" || + arg == "textit" || arg == "textsc" || + arg == "textsl" || arg == "textup" || + arg == "texttt" || arg == "textbb" || + arg == "textnormal"; + flag.setEnabled(currentMode() != TEXT_MODE || textarg); break; } + case LFUN_MATH_MODE: + // forbid "math-mode on" in math mode to prevent irritating + // behaviour of menu entries (bug 6709) + flag.setEnabled(currentMode() == TEXT_MODE || arg != "on"); + break; + + case LFUN_MATH_INSERT: + flag.setEnabled(currentMode() != TEXT_MODE); + break; + + case LFUN_MATH_AMS_MATRIX: case LFUN_MATH_MATRIX: - flag.enabled(currentMode() == MATH_MODE); + flag.setEnabled(currentMode() == MATH_MODE); break; case LFUN_INSET_INSERT: { @@ -1169,37 +1423,60 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, // getStatus is not called with a valid reference and the // dialog would not be applyable. string const name = cmd.getArg(0); - flag.enabled(name == "ref"); + flag.setEnabled(name == "ref" || name == "mathspace"); break; } + case LFUN_DIALOG_SHOW_NEW_INSET: { + docstring const & name = cmd.argument(); + if (name == "space") + flag.setEnabled(false); + break; + } + + case LFUN_MATH_DELIM: case LFUN_MATH_BIGDELIM: // Don't do this with multi-cell selections - flag.enabled(cur.selBegin().idx() == cur.selEnd().idx()); + flag.setEnabled(cur.selBegin().idx() == cur.selEnd().idx()); break; - + case LFUN_MATH_MACRO_FOLD: case LFUN_MATH_MACRO_UNFOLD: { Cursor it = cur; - bool found = findMacroToFoldUnfold(it, cmd.action == LFUN_MATH_MACRO_FOLD); - flag.enabled(found); + bool found = findMacroToFoldUnfold(it, cmd.action() == LFUN_MATH_MACRO_FOLD); + flag.setEnabled(found); break; } - - case LFUN_HYPHENATION_POINT_INSERT: - case LFUN_LIGATURE_BREAK_INSERT: - case LFUN_MENU_SEPARATOR_INSERT: - case LFUN_DOTS_INSERT: - case LFUN_END_OF_SENTENCE_PERIOD_INSERT: + + case LFUN_SPECIALCHAR_INSERT: + case LFUN_SCRIPT_INSERT: // FIXME: These would probably make sense in math-text mode - flag.enabled(false); + flag.setEnabled(false); + break; + + case LFUN_CAPTION_INSERT: + flag.setEnabled(false); + break; + + case LFUN_SPACE_INSERT: { + docstring const & name = cmd.argument(); + if (name == "visible") + flag.setEnabled(false); break; + } case LFUN_INSET_DISSOLVE: - flag.enabled(!asHullInset()); + flag.setEnabled(!asHullInset()); break; + case LFUN_PASTE: { + docstring const & name = cmd.argument(); + if (name == "html" || name == "latex") + flag.setEnabled(false); + break; + } + default: ret = false; break; @@ -1208,11 +1485,13 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, } -void InsetMathNest::edit(Cursor & cur, bool left) +void InsetMathNest::edit(Cursor & cur, bool front, EntryDirection entry_from) { cur.push(*this); - cur.idx() = left ? 0 : cur.lastidx(); - cur.pos() = left ? 0 : cur.lastpos(); + bool enter_front = (entry_from == Inset::ENTRY_DIRECTION_RIGHT || + (entry_from == Inset::ENTRY_DIRECTION_IGNORE && front)); + cur.idx() = enter_front ? 0 : cur.lastidx(); + cur.pos() = enter_front ? 0 : cur.lastpos(); cur.resetAnchor(); //lyxerr << "InsetMathNest::edit, cur:\n" << cur << endl; } @@ -1232,7 +1511,7 @@ Inset * InsetMathNest::editXY(Cursor & cur, int x, int y) MathData & ar = cell(idx_min); cur.push(*this); cur.idx() = idx_min; - cur.pos() = ar.x2pos(x - ar.xo(cur.bv())); + cur.pos() = ar.x2pos(&cur.bv(), x - ar.xo(cur.bv())); //lyxerr << "found cell : " << idx_min << " pos: " << cur.pos() << endl; if (dist_min == 0) { @@ -1249,6 +1528,15 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd) { //lyxerr << "## lfunMousePress: buttons: " << cmd.button() << endl; BufferView & bv = cur.bv(); + if (cmd.button() == mouse_button::button3) { + // Don't do anything if we right-click a + // selection, a context menu will popup. + if (bv.cursor().selection() && cur >= bv.cursor().selectionBegin() + && cur < bv.cursor().selectionEnd()) { + cur.noScreenUpdate(); + return; + } + } bool do_selection = cmd.button() == mouse_button::button1 && cmd.argument() == "region-select"; bv.mouseSetCursor(cur, do_selection); @@ -1262,9 +1550,9 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd) // Update::FitCursor: adjust the screen to the cursor // position if needed // cur.result().update(): don't overwrite previously set flags. - cur.updateFlags(Update::Decoration | Update::FitCursor - | cur.result().update()); - } else if (cmd.button() == mouse_button::button2) { + cur.screenUpdateFlags(Update::Decoration | Update::FitCursor + | cur.result().screenUpdate()); + } else if (cmd.button() == mouse_button::button2 && lyxrc.mouse_middlebutton_paste) { if (cap::selection()) { // See comment in Text::dispatch why we do this cap::copySelectionToStack(); @@ -1282,16 +1570,29 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd) void InsetMathNest::lfunMouseMotion(Cursor & cur, FuncRequest & cmd) { // only select with button 1 - if (cmd.button() == mouse_button::button1) { - Cursor & bvcur = cur.bv().cursor(); - if (bvcur.anchor_.hasPart(cur)) { - //lyxerr << "## lfunMouseMotion: cursor: " << cur << endl; - bvcur.setCursor(cur); - bvcur.selection() = true; - //lyxerr << "MOTION " << bvcur << endl; - } else - cur.undispatched(); + if (cmd.button() != mouse_button::button1) + return; + + Cursor & bvcur = cur.bv().cursor(); + + // ignore motions deeper nested than the real anchor + if (!bvcur.realAnchor().hasPart(cur)) { + cur.undispatched(); + return; } + + CursorSlice old = bvcur.top(); + + // We continue with our existing selection or start a new one, so don't + // reset the anchor. + bvcur.setCursor(cur); + // Did we actually move? + if (cur.top() == old) + // We didn't move one iota, so no need to change selection status + // or update the screen. + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); + else + bvcur.setSelection(); } @@ -1301,10 +1602,10 @@ void InsetMathNest::lfunMouseRelease(Cursor & cur, FuncRequest & cmd) if (cmd.button() == mouse_button::button1) { if (!cur.selection()) - cur.noUpdate(); + cur.noScreenUpdate(); else { Cursor & bvcur = cur.bv().cursor(); - bvcur.selection() = true; + bvcur.setSelection(true); } return; } @@ -1313,7 +1614,7 @@ void InsetMathNest::lfunMouseRelease(Cursor & cur, FuncRequest & cmd) } -bool InsetMathNest::interpretChar(Cursor & cur, char_type c) +bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) { //lyxerr << "interpret 2: '" << c << "'" << endl; docstring save_selection; @@ -1321,6 +1622,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) save_selection = grabAndEraseSelection(cur); cur.clearTargetX(); + Buffer * buf = cur.buffer(); // handle macroMode if (cur.inMacroMode()) { @@ -1335,7 +1637,11 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) return true; } - if (isAlphaASCII(c)) { + // do not finish macro for known * commands + bool star_macro = c == '*' + && (in_word_set(name.substr(1) + '*') + || cur.buffer()->getMacro(name.substr(1) + "*", cur, true)); + if (isAlphaASCII(c) || star_macro) { cur.activeMacro()->setName(name + docstring(1, c)); return true; } @@ -1345,22 +1651,25 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) // remove the '\\' if (c == '\\') { cur.backspace(); - if (currentMode() == InsetMath::TEXT_MODE) - cur.niceInsert(createInsetMath("textbackslash")); + if (currentMode() <= InsetMath::TEXT_MODE) + cur.niceInsert(createInsetMath("textbackslash", buf)); else - cur.niceInsert(createInsetMath("backslash")); + cur.niceInsert(createInsetMath("backslash", buf)); + } else if (c == '^' && currentMode() == InsetMath::MATH_MODE) { + cur.backspace(); + cur.niceInsert(createInsetMath("mathcircumflex", buf)); } else if (c == '{') { cur.backspace(); - cur.niceInsert(MathAtom(new InsetMathBrace)); + cur.niceInsert(MathAtom(new InsetMathBrace(buf))); } else if (c == '%') { cur.backspace(); - cur.niceInsert(MathAtom(new InsetMathComment)); + cur.niceInsert(MathAtom(new InsetMathComment(buf))); } else if (c == '#') { - BOOST_ASSERT(cur.activeMacro()); + LASSERT(cur.activeMacro(), return false); cur.activeMacro()->setName(name + docstring(1, c)); } else { cur.backspace(); - cur.niceInsert(createInsetMath(docstring(1, c))); + cur.niceInsert(createInsetMath(docstring(1, c), buf)); } return true; } @@ -1393,61 +1702,84 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) new InsetMathBig(name.substr(1), delim))); return true; } + } else if (name == "\\smash" && c == '[') { + // We can't use cur.macroModeClose() because + // it would create an InsetMathPhantom + InsetMathUnknown * p = cur.activeMacro(); + p->finalize(); + interpretChar(cur, c); + return true; } // leave macro mode and try again if necessary - cur.macroModeClose(); + if (cur.macroModeClose()) { + MathAtom const atom = cur.prevAtom(); + if (atom->asNestInset() && atom->isActive()) { + cur.posBackward(); + cur.pushBackward(*cur.nextInset()); + } + } if (c == '{') - cur.niceInsert(MathAtom(new InsetMathBrace)); + cur.niceInsert(MathAtom(new InsetMathBrace(buf))); else if (c != ' ') interpretChar(cur, c); return true; } - // This is annoying as one has to press far too often. - // Disable it. -#if 0 - // leave autocorrect mode if necessary - if (autocorrect() && c == ' ') { - autocorrect() = false; - return true; - } -#endif + // leave autocorrect mode if necessary + if (lyxrc.autocorrection_math && c == ' ' && cur.autocorrect()) { + cur.autocorrect() = false; + cur.message(_("Autocorrect Off ('!' to enter)")); + return true; + } + if (lyxrc.autocorrection_math && c == '!' && !cur.autocorrect()) { + cur.autocorrect() = true; + cur.message(_("Autocorrect On ( to exit)")); + return true; + } // just clear selection on pressing the space bar if (cur.selection() && c == ' ') { - cur.selection() = false; + cur.setSelection(false); return true; } - selClearOrDel(cur); - if (c == '\\') { //lyxerr << "starting with macro" << endl; - cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), false))); + bool reduced = cap::reduceSelectionToOneCell(cur); + if (reduced || !cur.selection()) { + cur.recordUndoInset(); + docstring const safe = cap::grabAndEraseSelection(cur); + if (!cur.inRegexped()) + cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false))); + else + cur.niceInsert(createInsetMath("backslash", buf)); + } return true; } + selClearOrDel(cur); + if (c == '\n') { - if (currentMode() == InsetMath::TEXT_MODE) + if (currentMode() <= InsetMath::TEXT_MODE) cur.insert(c); return true; } if (c == ' ') { - if (currentMode() == InsetMath::TEXT_MODE) { - // insert spaces in text mode, + if (currentMode() <= InsetMath::TEXT_MODE) { + // insert spaces in text or undecided 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 (!cur.pos() != 0 || cur.prevAtom()->getChar() != ' ') { + if (cur.pos() == 0 || cur.prevAtom()->getChar() != ' ') { cur.insert(c); // FIXME: we have to enable full redraw here because of the // visual box corners that define the inset. If we know for // sure that we stay within the same cell we can optimize for // that using: - //cur.updateFlags(Update::SinglePar | Update::FitCursor); + //cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); } return true; } @@ -1457,16 +1789,16 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) // visual box corners that define the inset. If we know for // sure that we stay within the same cell we can optimize for // that using: - //cur.updateFlags(Update::SinglePar | Update::FitCursor); + //cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); return true; } - if (cur.popRight()) { + if (cur.popForward()) { // FIXME: we have to enable full redraw here because of the // visual box corners that define the inset. If we know for // sure that we stay within the same cell we can optimize for // that using: - //cur.updateFlags(Update::FitCursor); + //cur.screenUpdateFlags(Update::FitCursor); return true; } @@ -1474,8 +1806,30 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) return cur.pos() != cur.lastpos(); } - // These shouldn't work in text mode: - if (currentMode() != InsetMath::TEXT_MODE) { + // These should be treated differently when not in text mode: + if (cur.inRegexped()) { + switch (c) { + case '\\': + cur.niceInsert(createInsetMath("backslash", buf)); + break; + case '^': + cur.niceInsert(createInsetMath("mathcircumflex", buf)); + break; + case '{': + case '}': + case '#': + case '%': + case '_': + cur.niceInsert(createInsetMath(docstring(1, c), buf)); + break; + case '~': + cur.niceInsert(createInsetMath("sim", buf)); + break; + default: + cur.insert(c); + } + return true; + } else if (currentMode() != InsetMath::TEXT_MODE) { if (c == '_') { script(cur, false, save_selection); return true; @@ -1485,25 +1839,47 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c) return true; } if (c == '~') { - cur.niceInsert(createInsetMath("sim")); + cur.niceInsert(createInsetMath("sim", buf)); + return true; + } + if (currentMode() == InsetMath::MATH_MODE && !isAsciiOrMathAlpha(c)) { + MathAtom at = createInsetMath("text", buf); + at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c))); + cur.niceInsert(at); + cur.posForward(); + return true; + } + } else { + if (c == '^') { + cur.niceInsert(createInsetMath("textasciicircum", buf)); + return true; + } + if (c == '~') { + cur.niceInsert(createInsetMath("textasciitilde", buf)); return true; } } if (c == '{' || c == '}' || c == '&' || c == '$' || c == '#' || - c == '%' || c == '_' || c == '^') { - cur.niceInsert(createInsetMath(docstring(1, c))); + c == '%' || c == '_') { + cur.niceInsert(createInsetMath(docstring(1, c), buf)); return true; } // try auto-correction - //if (autocorrect() && hasPrevAtom() && math_autocorrect(prevAtom(), c)) - // return true; + if (lyxrc.autocorrection_math && cur.autocorrect() && cur.pos() != 0 + && math_autocorrect(cur.prevAtom(), c)) + return true; // no special circumstances, so insert the character without any fuss cur.insert(c); - cur.autocorrect() = true; + if (lyxrc.autocorrection_math) { + if (!cur.autocorrect()) + cur.message(_("Autocorrect Off ('!' to enter)")); + else + cur.message(_("Autocorrect On ( to exit)")); + } return true; } @@ -1531,6 +1907,12 @@ bool InsetMathNest::interpretString(Cursor & cur, docstring const & str) } +bool InsetMathNest::script(Cursor & cur, bool up) +{ + return script(cur, up, docstring()); +} + + bool InsetMathNest::script(Cursor & cur, bool up, docstring const & save_selection) { @@ -1538,7 +1920,7 @@ bool InsetMathNest::script(Cursor & cur, bool up, //lyxerr << "handling script: up: " << up << endl; if (cur.inMacroMode() && cur.macroName() == "\\") { if (up) - cur.niceInsert(createInsetMath("mathcircumflex")); + cur.niceInsert(createInsetMath("mathcircumflex", cur.buffer())); else interpretChar(cur, '_'); return true; @@ -1564,10 +1946,10 @@ bool InsetMathNest::script(Cursor & cur, bool up, // one if in the very first position of the array if (cur.pos() == 0) { //lyxerr << "new scriptinset" << endl; - cur.insert(new InsetMathScript(up)); + cur.insert(new InsetMathScript(buffer_, up)); } else { //lyxerr << "converting prev atom " << endl; - cur.prevAtom() = MathAtom(new InsetMathScript(cur.prevAtom(), up)); + cur.prevAtom() = MathAtom(new InsetMathScript(buffer_, cur.prevAtom(), up)); } --cur.pos(); InsetMathScript * inset = cur.nextAtom().nucleus()->asScriptInset(); @@ -1585,4 +1967,286 @@ bool InsetMathNest::script(Cursor & cur, bool up, } +bool InsetMathNest::completionSupported(Cursor const & cur) const +{ + return cur.inMacroMode(); +} + + +bool InsetMathNest::inlineCompletionSupported(Cursor const & cur) const +{ + return cur.inMacroMode(); +} + + +bool InsetMathNest::automaticInlineCompletion() const +{ + return lyxrc.completion_inline_math; +} + + +bool InsetMathNest::automaticPopupCompletion() const +{ + return lyxrc.completion_popup_math; +} + + +CompletionList const * +InsetMathNest::createCompletionList(Cursor const & cur) const +{ + if (!cur.inMacroMode()) + return 0; + + return new MathCompletionList(cur); +} + + +docstring InsetMathNest::completionPrefix(Cursor const & cur) const +{ + if (!cur.inMacroMode()) + return docstring(); + + return cur.activeMacro()->name(); +} + + +bool InsetMathNest::insertCompletion(Cursor & cur, docstring const & s, + bool finished) +{ + if (!cur.inMacroMode()) + return false; + + // append completion to active macro + InsetMathUnknown * inset = cur.activeMacro(); + inset->setName(inset->name() + s); + + // finish macro + if (finished) { +#if 0 + // FIXME: this creates duplicates in the completion popup + // which looks ugly. Moreover the changes the list lengths + // which seems to + confuse the popup as well. + MathCompletionList::addToFavorites(inset->name()); +#endif + lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, " ")); + } + + return true; +} + + +void InsetMathNest::completionPosAndDim(Cursor const & cur, int & x, int & y, + Dimension & dim) const +{ + Inset const * inset = cur.activeMacro(); + if (!inset) + return; + + // get inset dimensions + dim = cur.bv().coordCache().insets().dim(inset); + // FIXME: these 3 are no accurate, but should depend on the font. + // Now the popup jumps down if you enter a char with descent > 0. + dim.des += 3; + dim.asc += 3; + + // and position + Point xy = cur.bv().coordCache().insets().xy(inset); + x = xy.x_; + y = xy.y_; +} + + +bool InsetMathNest::cursorMathForward(Cursor & cur) +{ + if (cur.pos() != cur.lastpos() && cur.openable(cur.nextAtom())) { + cur.pushBackward(*cur.nextAtom().nucleus()); + cur.inset().idxFirst(cur); + return true; + } + if (cur.posForward() || idxForward(cur)) + return true; + // try to pop forwards --- but don't pop out of math! leave that to + // the FINISH lfuns + int s = cur.depth() - 2; + if (s >= 0 && cur[s].inset().asInsetMath()) + return cur.popForward(); + return false; +} + + +bool InsetMathNest::cursorMathBackward(Cursor & cur) +{ + if (cur.pos() != 0 && cur.openable(cur.prevAtom())) { + cur.posBackward(); + cur.push(*cur.nextAtom().nucleus()); + cur.inset().idxLast(cur); + return true; + } + if (cur.posBackward() || idxBackward(cur)) + return true; + // try to pop backwards --- but don't pop out of math! leave that to + // the FINISH lfuns + int s = cur.depth() - 2; + if (s >= 0 && cur[s].inset().asInsetMath()) + return cur.popBackward(); + return false; +} + + +//////////////////////////////////////////////////////////////////// + +MathCompletionList::MathCompletionList(Cursor const & cur) +{ + // fill it with macros from the buffer + MacroNameSet macros; + cur.buffer()->listMacroNames(macros); + MacroNameSet::const_iterator it; + for (it = macros.begin(); it != macros.end(); ++it) { + if (cur.buffer()->getMacro(*it, cur, false)) + locals.push_back("\\" + *it); + } + sort(locals.begin(), locals.end()); + + if (!globals.empty()) + return; + + // fill in global macros + macros.clear(); + MacroTable::globalMacros().getMacroNames(macros, false); + //lyxerr << "Globals completion macros: "; + for (it = macros.begin(); it != macros.end(); ++it) { + //lyxerr << "\\" + *it << " "; + globals.push_back("\\" + *it); + } + //lyxerr << std::endl; + + // fill in global commands + globals.push_back(from_ascii("\\boxed")); + globals.push_back(from_ascii("\\fbox")); + globals.push_back(from_ascii("\\framebox")); + globals.push_back(from_ascii("\\makebox")); + globals.push_back(from_ascii("\\kern")); + globals.push_back(from_ascii("\\xhookrightarrow")); + globals.push_back(from_ascii("\\xhookleftarrow")); + globals.push_back(from_ascii("\\xrightarrow")); + globals.push_back(from_ascii("\\xRightarrow")); + globals.push_back(from_ascii("\\xrightharpoondown")); + globals.push_back(from_ascii("\\xrightharpoonup")); + globals.push_back(from_ascii("\\xrightleftharpoons")); + globals.push_back(from_ascii("\\xleftarrow")); + globals.push_back(from_ascii("\\xLeftarrow")); + globals.push_back(from_ascii("\\xleftharpoondown")); + globals.push_back(from_ascii("\\xleftharpoonup")); + globals.push_back(from_ascii("\\xleftrightarrow")); + globals.push_back(from_ascii("\\xLeftrightarrow")); + globals.push_back(from_ascii("\\xleftrightharpoons")); + globals.push_back(from_ascii("\\xmapsto")); + globals.push_back(from_ascii("\\split")); + globals.push_back(from_ascii("\\gathered")); + globals.push_back(from_ascii("\\aligned")); + globals.push_back(from_ascii("\\alignedat")); + globals.push_back(from_ascii("\\cases")); + globals.push_back(from_ascii("\\substack")); + globals.push_back(from_ascii("\\xymatrix")); + globals.push_back(from_ascii("\\Diagram")); + globals.push_back(from_ascii("\\subarray")); + globals.push_back(from_ascii("\\array")); + globals.push_back(from_ascii("\\sqrt")); + globals.push_back(from_ascii("\\root")); + globals.push_back(from_ascii("\\tabular")); + globals.push_back(from_ascii("\\stackrel")); + globals.push_back(from_ascii("\\stackrelthree")); + globals.push_back(from_ascii("\\binom")); + globals.push_back(from_ascii("\\choose")); + globals.push_back(from_ascii("\\brace")); + globals.push_back(from_ascii("\\brack")); + globals.push_back(from_ascii("\\frac")); + globals.push_back(from_ascii("\\over")); + globals.push_back(from_ascii("\\nicefrac")); + globals.push_back(from_ascii("\\unitfrac")); + globals.push_back(from_ascii("\\unitfracthree")); + globals.push_back(from_ascii("\\unitone")); + globals.push_back(from_ascii("\\unittwo")); + globals.push_back(from_ascii("\\infer")); + globals.push_back(from_ascii("\\atop")); + globals.push_back(from_ascii("\\lefteqn")); + globals.push_back(from_ascii("\\boldsymbol")); + globals.push_back(from_ascii("\\bm")); + globals.push_back(from_ascii("\\color")); + globals.push_back(from_ascii("\\normalcolor")); + globals.push_back(from_ascii("\\textcolor")); + globals.push_back(from_ascii("\\cfrac")); + globals.push_back(from_ascii("\\cfracleft")); + globals.push_back(from_ascii("\\cfracright")); + globals.push_back(from_ascii("\\dfrac")); + globals.push_back(from_ascii("\\tfrac")); + globals.push_back(from_ascii("\\dbinom")); + globals.push_back(from_ascii("\\tbinom")); + globals.push_back(from_ascii("\\hphantom")); + globals.push_back(from_ascii("\\phantom")); + globals.push_back(from_ascii("\\vphantom")); + globals.push_back(from_ascii("\\cancel")); + globals.push_back(from_ascii("\\bcancel")); + globals.push_back(from_ascii("\\xcancel")); + globals.push_back(from_ascii("\\cancelto")); + globals.push_back(from_ascii("\\smash")); + globals.push_back(from_ascii("\\mathclap")); + globals.push_back(from_ascii("\\mathllap")); + globals.push_back(from_ascii("\\mathrlap")); + MathWordList const & words = mathedWordList(); + MathWordList::const_iterator it2; + //lyxerr << "Globals completion commands: "; + for (it2 = words.begin(); it2 != words.end(); ++it2) { + if (it2->second.inset != "macro" && !it2->second.hidden) { + // macros are already read from MacroTable::globalMacros() + globals.push_back('\\' + it2->first); + //lyxerr << '\\' + it2->first << ' '; + } + } + //lyxerr << std::endl; + sort(globals.begin(), globals.end()); +} + + +MathCompletionList::~MathCompletionList() +{ +} + + +size_type MathCompletionList::size() const +{ + return locals.size() + globals.size(); +} + + +docstring const & MathCompletionList::data(size_t idx) const +{ + size_t lsize = locals.size(); + if (idx >= lsize) + return globals[idx - lsize]; + else + return locals[idx]; +} + + +std::string MathCompletionList::icon(size_t idx) const +{ + // get the latex command + docstring cmd; + size_t lsize = locals.size(); + if (idx >= lsize) + cmd = globals[idx - lsize]; + else + cmd = locals[idx]; + + // get the icon resource name by stripping the backslash + docstring icon_name = frontend::Application::mathIcon(cmd.substr(1)); + if (icon_name.empty()) + return std::string(); + return "images/math/" + to_utf8(icon_name); +} + +std::vector MathCompletionList::globals; + } // namespace lyx