X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathNest.cpp;h=179d7775f32015e04c08f234a806957d10fb669b;hb=d48e5330bee3218336fb443d726b625c84eacf10;hp=21d5af1a718c85955d64bd878649304885b62fe4;hpb=489b80aef4d7904d667aeb06a32f2cc4ecbb75fa;p=lyx.git diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp index 21d5af1a71..179d7775f3 100644 --- a/src/mathed/InsetMathNest.cpp +++ b/src/mathed/InsetMathNest.cpp @@ -40,6 +40,7 @@ #include "Bidi.h" #include "Buffer.h" +#include "BufferParams.h" #include "BufferView.h" #include "CoordCache.h" #include "Cursor.h" @@ -48,7 +49,7 @@ #include "Encoding.h" #include "FuncRequest.h" #include "FuncStatus.h" -#include "LyXFunc.h" +#include "LyX.h" #include "LyXRC.h" #include "OutputParams.h" #include "Text.h" @@ -80,23 +81,32 @@ using cap::selClearOrDel; InsetMathNest::InsetMathNest(Buffer * buf, idx_type nargs) - : InsetMath(buf), cells_(nargs), lock_(false), mouse_hover_(false) + : 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; } @@ -130,7 +140,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. - LASSERT(&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)) { @@ -173,17 +183,17 @@ void InsetMathNest::metrics(MetricsInfo const & mi) const } -void InsetMathNest::updateLabels(ParIterator const & it, UpdateType utype) +void InsetMathNest::updateBuffer(ParIterator const & it, UpdateType utype) { for (idx_type i = 0, n = nargs(); i != n; ++i) - cell(i).updateLabels(it, utype); + cell(i).updateBuffer(it, utype); } bool InsetMathNest::idxNext(Cursor & cur) const { - LASSERT(&cur.inset() == this, /**/); + LASSERT(&cur.inset() == this, return false); if (cur.idx() == cur.lastidx()) return false; ++cur.idx(); @@ -200,7 +210,7 @@ bool InsetMathNest::idxForward(Cursor & cur) const bool InsetMathNest::idxPrev(Cursor & cur) const { - LASSERT(&cur.inset() == this, /**/); + LASSERT(&cur.inset() == this, return false); if (cur.idx() == 0) return false; --cur.idx(); @@ -217,7 +227,7 @@ bool InsetMathNest::idxBackward(Cursor & cur) const bool InsetMathNest::idxFirst(Cursor & cur) const { - LASSERT(&cur.inset() == this, /**/); + LASSERT(&cur.inset() == this, return false); if (nargs() == 0) return false; cur.idx() = 0; @@ -228,7 +238,7 @@ bool InsetMathNest::idxFirst(Cursor & cur) const bool InsetMathNest::idxLast(Cursor & cur) const { - LASSERT(&cur.inset() == this, /**/); + LASSERT(&cur.inset() == this, return false); if (nargs() == 0) return false; cur.idx() = cur.lastidx(); @@ -362,6 +372,7 @@ MathData InsetMathNest::glue() const void InsetMathNest::write(WriteStream & os) const { + MathEnsurer ensurer(os, currentMode() == MATH_MODE); ModeSpecifier specifier(os, currentMode(), lockedMode()); docstring const latex_name = name(); os << '\\' << latex_name; @@ -385,19 +396,31 @@ void InsetMathNest::normalize(NormalStream & os) const } -int InsetMathNest::latex(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; } @@ -542,7 +565,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) Parse::flags parseflg = Parse::QUIET | Parse::USETEXT; - switch (cmd.action) { + FuncCode const act = cmd.action(); + switch (act) { case LFUN_CLIPBOARD_PASTE: parseflg |= Parse::VERBATIM; @@ -555,17 +579,16 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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::selection(n); + topaste = cap::selection(n, buffer().params().documentClassPtr()); } cur.niceInsert(topaste, parseflg, false); cur.clearSelection(); // bug 393 - // FIXME audit setBuffer/updateLabels calls - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); cur.finishUndo(); break; } @@ -577,8 +600,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(); - // FIXME audit setBuffer/updateLabels calls - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); break; case LFUN_COPY: @@ -613,16 +635,16 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_LEFT: case LFUN_CHAR_BACKWARD: case LFUN_CHAR_FORWARD: - cur.updateFlags(Update::Decoration | Update::FitCursor); + 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 = (cmd.action == LFUN_CHAR_RIGHT_SELECT - || cmd.action == LFUN_CHAR_LEFT_SELECT - || cmd.action == LFUN_CHAR_BACKWARD_SELECT - || cmd.action == LFUN_CHAR_FORWARD_SELECT); + 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): @@ -634,19 +656,19 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) bool forward; FuncCode finish_lfun; - if (cmd.action == LFUN_CHAR_FORWARD - || cmd.action == LFUN_CHAR_FORWARD_SELECT) { + if (act == LFUN_CHAR_FORWARD + || act == LFUN_CHAR_FORWARD_SELECT) { forward = true; finish_lfun = LFUN_FINISHED_FORWARD; } - else if (cmd.action == LFUN_CHAR_BACKWARD - || cmd.action == LFUN_CHAR_BACKWARD_SELECT) { + else if (act == LFUN_CHAR_BACKWARD + || act == LFUN_CHAR_BACKWARD_SELECT) { forward = false; finish_lfun = LFUN_FINISHED_BACKWARD; } else { - bool right = (cmd.action == LFUN_CHAR_RIGHT_SELECT - || cmd.action == LFUN_CHAR_RIGHT); + bool right = (act == LFUN_CHAR_RIGHT_SELECT + || act == LFUN_CHAR_RIGHT); if (lyxrc.visual_cursor || !reverseDirectionNeeded(cur)) forward = right; else @@ -673,7 +695,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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 @@ -683,12 +705,16 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } // 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) break; @@ -710,13 +736,14 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.idx() = 0; cur.resetAnchor(); cur.setSelection(true); - cur.pos() = cur.lastpos(); 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; @@ -724,13 +751,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; @@ -749,13 +776,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()) { @@ -773,12 +800,12 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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; @@ -787,7 +814,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (cur.pos() == 0) // May affect external cell: cur.recordUndoInset(); - else + else if (!cur.inMacroMode()) cur.recordUndoSelection(); // if the inset can not be removed from within, delete it if (!cur.backspace()) { @@ -853,7 +880,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) // 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.posBackward(); @@ -980,7 +1007,6 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.macroModeClose(); docstring const save_selection = grabAndEraseSelection(cur); selClearOrDel(cur); - //cur.plainInsert(MathAtom(new InsetMathMBox(cur.bv()))); if (currentMode() <= Inset::TEXT_MODE) cur.plainInsert(MathAtom(new InsetMathEnsureMath(buffer_))); else @@ -988,8 +1014,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.posBackward(); cur.pushBackward(*cur.nextInset()); cur.niceInsert(save_selection); - // FIXME audit setBuffer/updateLabels calls - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); #else if (currentMode() == Inset::TEXT_MODE) { cur.recordUndoSelection(); @@ -1004,10 +1029,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_REGEXP_MODE: { - InsetMathHull * i = dynamic_cast(cur.inset().asInsetMath()); - if (i && i->getType() == hullRegexp) { - cur.message(_("Already in regular expression mode")); - break; + 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); @@ -1054,13 +1082,19 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.recordUndo(); unsigned int m = 1; unsigned int n = 1; - docstring name; + 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 InsetMathAMSArray(buffer_, name, m, n))); break; @@ -1099,20 +1133,48 @@ 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(); - cur.insert(MathAtom(new InsetMathSpace)); + 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.recordUndoSelection(); @@ -1146,7 +1208,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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) { MathMacro * macro = it.nextInset()->asInsetMath()->asMacro(); @@ -1183,19 +1245,34 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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(buffer_, name); - data = tmp.createDialogStr(to_utf8(name)); - } else if (name == "mathspace") { - InsetMathSpace tmp; data = tmp.createDialogStr(); + cur.bv().showDialog(to_utf8(name), data); + } else if (name == "mathspace") { + cur.bv().showDialog(to_utf8(name)); } - cur.bv().showDialog(to_utf8(name), data); break; } @@ -1204,8 +1281,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (createInsetMath_fromDialogStr(cmd.argument(), ar)) { cur.recordUndoSelection(); cur.insert(ar); - // FIXME audit setBuffer/updateLabels calls - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); } else cur.undispatched(); break; @@ -1265,12 +1341,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: + 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(); @@ -1305,7 +1381,6 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, // 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_EXTERN: flag.setEnabled(true); break; @@ -1327,6 +1402,12 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, 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; @@ -1345,6 +1426,14 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, 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 @@ -1354,20 +1443,39 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_MATH_MACRO_FOLD: case LFUN_MATH_MACRO_UNFOLD: { Cursor it = cur; - bool found = findMacroToFoldUnfold(it, cmd.action == LFUN_MATH_MACRO_FOLD); + bool found = findMacroToFoldUnfold(it, cmd.action() == LFUN_MATH_MACRO_FOLD); flag.setEnabled(found); break; } case LFUN_SPECIALCHAR_INSERT: + case LFUN_SCRIPT_INSERT: // FIXME: These would probably make sense in math-text mode 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.setEnabled(!asHullInset()); break; + case LFUN_PASTE: { + docstring const & name = cmd.argument(); + if (name == "html" || name == "latex") + flag.setEnabled(false); + break; + } + default: ret = false; break; @@ -1419,6 +1527,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); @@ -1432,9 +1549,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(); @@ -1452,16 +1569,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.setSelection(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(); } @@ -1471,7 +1601,7 @@ 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.setSelection(true); @@ -1507,9 +1637,8 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) } // do not finish macro for known * commands - MathWordList const & mwl = mathedWordList(); bool star_macro = c == '*' - && (mwl.find(name.substr(1) + "*") != mwl.end() + && (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)); @@ -1535,7 +1664,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) cur.backspace(); cur.niceInsert(MathAtom(new InsetMathComment(buf))); } else if (c == '#') { - LASSERT(cur.activeMacro(), /**/); + LASSERT(cur.activeMacro(), return false); cur.activeMacro()->setName(name + docstring(1, c)); } else { cur.backspace(); @@ -1572,6 +1701,13 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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 @@ -1595,7 +1731,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) 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)")); @@ -1612,8 +1748,12 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) //lyxerr << "starting with macro" << endl; bool reduced = cap::reduceSelectionToOneCell(cur); if (reduced || !cur.selection()) { + cur.recordUndoInset(); docstring const safe = cap::grabAndEraseSelection(cur); - cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false))); + if (!cur.inRegexped()) + cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false))); + else + cur.niceInsert(createInsetMath("backslash", buf)); } return true; } @@ -1632,13 +1772,13 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) // 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; } @@ -1648,7 +1788,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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; } @@ -1657,7 +1797,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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::FitCursor); + //cur.screenUpdateFlags(Update::FitCursor); return true; } @@ -1666,7 +1806,29 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) } // These should be treated differently when not in text mode: - if (currentMode() != InsetMath::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; @@ -1888,8 +2050,7 @@ void InsetMathNest::completionPosAndDim(Cursor const & cur, int & x, int & y, dim.asc += 3; // and position - Point xy - = cur.bv().coordCache().insets().xy(inset); + Point xy = cur.bv().coordCache().insets().xy(inset); x = xy.x_; y = xy.y_; } @@ -1946,7 +2107,7 @@ MathCompletionList::MathCompletionList(Cursor const & cur) } sort(locals.begin(), locals.end()); - if (globals.size() > 0) + if (!globals.empty()) return; // fill in global macros @@ -1965,8 +2126,21 @@ MathCompletionList::MathCompletionList(Cursor const & cur) 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")); @@ -1974,12 +2148,14 @@ MathCompletionList::MathCompletionList(Cursor const & cur) 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")); @@ -2009,12 +2185,23 @@ MathCompletionList::MathCompletionList(Cursor const & cur) 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) { - globals.push_back("\\" + (*it2).first); - //lyxerr << "\\" + (*it2).first << " "; + if (it2->second.inset != "macro") { + // macros are already read from MacroTable::globalMacros() + globals.push_back('\\' + it2->first); + //lyxerr << '\\' + it2->first << ' '; + } } //lyxerr << std::endl; sort(globals.begin(), globals.end());