X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathNest.cpp;h=596e32aa006e9e2ddb413732fb77a2147cbdf7c9;hb=1538a8352ca82914bc131f2bf98b0ef4f55c1e2d;hp=d0c2397a2e47b5fdb1e020b94421fb14cff8ddd9;hpb=573500dd04f154f27318ac5ec469a337f97fe9f0;p=lyx.git diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp index d0c2397a2e..596e32aa00 100644 --- a/src/mathed/InsetMathNest.cpp +++ b/src/mathed/InsetMathNest.cpp @@ -38,8 +38,8 @@ #include "MathStream.h" #include "MathSupport.h" -#include "Bidi.h" #include "Buffer.h" +#include "BufferParams.h" #include "BufferView.h" #include "CoordCache.h" #include "Cursor.h" @@ -48,21 +48,25 @@ #include "Encoding.h" #include "FuncRequest.h" #include "FuncStatus.h" +#include "LaTeXFeatures.h" #include "LyX.h" #include "LyXRC.h" +#include "MetricsInfo.h" #include "OutputParams.h" +#include "TexRow.h" #include "Text.h" +#include "frontends/Application.h" #include "frontends/Clipboard.h" #include "frontends/Painter.h" #include "frontends/Selection.h" -#include "support/lassert.h" #include "support/debug.h" +#include "support/docstream.h" #include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" #include "support/textutils.h" -#include "support/docstream.h" #include #include @@ -139,7 +143,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)) { @@ -167,17 +171,19 @@ void InsetMathNest::cursorPos(BufferView const & bv, // << " asc: " << ascent() << " des: " << descent() // << " ar.asc: " << ar.ascent() << " ar.des: " << ar.descent() << endl; // move cursor visually into empty cells ("blue rectangles"); - if (ar.empty()) - x += 2; + if (ar.empty()) { + Dimension const dim = coord_cache.getArrays().dim(&ar); + x += dim.wid / 3; + } } -void InsetMathNest::metrics(MetricsInfo const & mi) const +void InsetMathNest::cellsMetrics(MetricsInfo const & mi) const { MetricsInfo m = mi; - for (idx_type i = 0, n = nargs(); i != n; ++i) { + for (auto const & cell : cells_) { Dimension dim; - cell(i).metrics(m, dim); + cell.metrics(m, dim); } } @@ -192,7 +198,7 @@ void InsetMathNest::updateBuffer(ParIterator const & it, UpdateType 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(); @@ -209,7 +215,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(); @@ -226,7 +232,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; @@ -237,7 +243,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(); @@ -249,7 +255,8 @@ bool InsetMathNest::idxLast(Cursor & cur) const void InsetMathNest::dump() const { odocstringstream oss; - WriteStream os(oss); + otexrowstream ots(oss); + WriteStream os(ots); os << "---------------------------------------------\n"; write(os); os << "\n"; @@ -260,62 +267,13 @@ void InsetMathNest::dump() const } -void InsetMathNest::draw(PainterInfo & pi, int x, int y) const +void InsetMathNest::draw(PainterInfo &, int, int) const { #if 0 if (lock_) pi.pain.fillRectangle(x, y - ascent(), width(), height(), Color_mathlockbg); #endif - setPosCache(pi, x, y); -} - - -void InsetMathNest::drawSelection(PainterInfo & pi, int x, int y) const -{ - BufferView & bv = *pi.base.bv; - // this should use the x/y values given, not the cached values - Cursor & cur = bv.cursor(); - if (!cur.selection()) - return; - 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(original_drawing_state); - - CursorSlice s1 = cur.selBegin(); - CursorSlice s2 = cur.selEnd(); - - //lyxerr << "InsetMathNest::drawing selection: " - // << " s1: " << s1 << " s2: " << s2 << endl; - 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(pi.base.bv, s1.pos()); - int y1 = g.pos.y_ - g.dim.ascent(); - 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: " - // << " x1: " << x1 << " x2: " << x2 - // << " y1: " << y1 << " y2: " << y2 << endl; - } else { - for (idx_type i = 0; i < nargs(); ++i) { - if (idxBetween(i, s1.idx(), s2.idx())) { - MathData const & c = cell(i); - Geometry const & g = bv.coordCache().getArrays().geometry(&c); - int x1 = g.pos.x_; - int y1 = g.pos.y_ - g.dim.ascent(); - int x2 = g.pos.x_ + g.dim.width(); - int y2 = g.pos.y_ + g.dim.descent(); - pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, Color_selection); - } - } - } } @@ -371,11 +329,14 @@ 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; - for (size_t i = 0; i < nargs(); ++i) + for (size_t i = 0; i < nargs(); ++i) { + Changer dummy = os.changeRowEntry(TexRow::mathEntry(id(),i)); os << '{' << cell(i) << '}'; + } if (nargs() == 0) os.pendingSpace(true); if (lock_ && !os.latex()) { @@ -394,17 +355,35 @@ 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, - runparams.dryrun ? WriteStream::wsDryrun : WriteStream::wsDefault, - runparams.encoding); + runparams.dryrun ? WriteStream::wsDryrun : WriteStream::wsDefault, + runparams.encoding); + wi.strikeoutMath(runparams.inDeletedInset + && (!LaTeXFeatures::isAvailable("dvipost") + || (runparams.flavor != OutputParams::LATEX + && runparams.flavor != OutputParams::DVILUATEX))); + if (runparams.inulemcmd) { + wi.ulemCmd(WriteStream::UNDERLINE); + if (runparams.local_font) { + FontInfo f = runparams.local_font->fontInfo(); + if (f.strikeout() == FONT_ON) + wi.ulemCmd(WriteStream::STRIKEOUT); + } + } + wi.canBreakLine(os.canBreakLine()); + Changer dummy = wi.changeRowEntry(TexRow::textEntry(runparams.lastid, + runparams.lastpos)); write(wi); - return wi.line(); + // Reset parbreak status after a math inset. + os.lastChar(0); + os.canBreakLine(wi.canBreakLine()); } bool InsetMathNest::setMouseHover(BufferView const * bv, bool mouse_hover) + const { mouse_hover_[bv] = mouse_hover; return true; @@ -558,19 +537,19 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) parseflg |= Parse::VERBATIM; // fall through case LFUN_PASTE: { - if (cur.currentMode() <= TEXT_MODE) + if (cur.currentMode() != MATH_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(frontend::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 @@ -617,20 +596,42 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.bv().cursor() = cur; break; + case LFUN_WORD_RIGHT: + case LFUN_WORD_LEFT: + case LFUN_WORD_BACKWARD: + case LFUN_WORD_FORWARD: case LFUN_CHAR_RIGHT: case LFUN_CHAR_LEFT: case LFUN_CHAR_BACKWARD: case LFUN_CHAR_FORWARD: cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); + // fall through + case LFUN_WORD_RIGHT_SELECT: + case LFUN_WORD_LEFT_SELECT: + case LFUN_WORD_BACKWARD_SELECT: + case LFUN_WORD_FORWARD_SELECT: 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 + bool select = (act == LFUN_WORD_RIGHT_SELECT + || act == LFUN_WORD_LEFT_SELECT + || act == LFUN_WORD_BACKWARD_SELECT + || act == LFUN_WORD_FORWARD_SELECT + || act == LFUN_CHAR_RIGHT_SELECT || act == LFUN_CHAR_LEFT_SELECT || act == LFUN_CHAR_BACKWARD_SELECT || act == LFUN_CHAR_FORWARD_SELECT); + // select words + bool word = (act == LFUN_WORD_RIGHT_SELECT + || act == LFUN_WORD_LEFT_SELECT + || act == LFUN_WORD_BACKWARD_SELECT + || act == LFUN_WORD_FORWARD_SELECT + || act == LFUN_WORD_RIGHT + || act == LFUN_WORD_LEFT + || act == LFUN_WORD_BACKWARD + || act == LFUN_WORD_FORWARD); // 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): @@ -643,19 +644,25 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) FuncCode finish_lfun; if (act == LFUN_CHAR_FORWARD - || act == LFUN_CHAR_FORWARD_SELECT) { + || act == LFUN_CHAR_FORWARD_SELECT + || act == LFUN_WORD_FORWARD + || act == LFUN_WORD_FORWARD_SELECT) { forward = true; finish_lfun = LFUN_FINISHED_FORWARD; } else if (act == LFUN_CHAR_BACKWARD - || act == LFUN_CHAR_BACKWARD_SELECT) { + || act == LFUN_CHAR_BACKWARD_SELECT + || act == LFUN_WORD_BACKWARD + || act == LFUN_WORD_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)) + || act == LFUN_CHAR_RIGHT + || act == LFUN_WORD_RIGHT_SELECT + || act == LFUN_WORD_RIGHT); + if (lyxrc.visual_cursor || !cur.reverseDirectionNeeded()) forward = right; else forward = !right; @@ -670,7 +677,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.clearTargetX(); cur.macroModeClose(); // try moving forward or backwards as necessary... - if (!(forward ? cursorMathForward(cur) : cursorMathBackward(cur))) { + if (!(forward ? cur.mathForward(word) : cur.mathBackward(word))) { // ... and if movement failed, then finish forward or backwards // as necessary cmd = FuncRequest(finish_lfun); @@ -681,9 +688,14 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_DOWN: case LFUN_UP: + case LFUN_PARAGRAPH_UP: + case LFUN_PARAGRAPH_DOWN: cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); + // fall through case LFUN_DOWN_SELECT: - case LFUN_UP_SELECT: { + case LFUN_UP_SELECT: + case LFUN_PARAGRAPH_UP_SELECT: + case LFUN_PARAGRAPH_DOWN_SELECT: { // close active macro if (cur.inMacroMode()) { cur.macroModeClose(); @@ -691,12 +703,21 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } // stop/start the selection - bool select = act == LFUN_DOWN_SELECT || - act == LFUN_UP_SELECT; + bool select = act == LFUN_DOWN_SELECT + || act == LFUN_UP_SELECT + || act == LFUN_PARAGRAPH_DOWN_SELECT + || act == LFUN_PARAGRAPH_UP_SELECT; cur.selHandle(select); + // handle autocorrect: + if (lyxrc.autocorrection_math && cur.autocorrect()) { + cur.autocorrect() = false; + cur.message(_("Autocorrect Off ('!' to enter)")); + } + // go up/down - bool up = act == LFUN_UP || act == LFUN_UP_SELECT; + bool up = act == LFUN_UP || act == LFUN_UP_SELECT + || act == LFUN_PARAGRAPH_UP || act == LFUN_PARAGRAPH_UP_SELECT; bool successful = cur.upDownInMath(up); if (successful) break; @@ -712,30 +733,28 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_MOUSE_DOUBLE: - case LFUN_MOUSE_TRIPLE: case LFUN_WORD_SELECT: cur.pos() = 0; - cur.idx() = 0; cur.resetAnchor(); - cur.setSelection(true); + cur.selection(true); cur.pos() = cur.lastpos(); - cur.idx() = cur.lastidx(); + cur.bv().cursor() = cur; break; - case LFUN_PARAGRAPH_UP: - case LFUN_PARAGRAPH_DOWN: - cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); - case LFUN_PARAGRAPH_UP_SELECT: - case LFUN_PARAGRAPH_DOWN_SELECT: + case LFUN_MOUSE_TRIPLE: + cur.idx() = 0; + cur.pos() = 0; + cur.resetAnchor(); + cur.selection(true); + cur.idx() = cur.lastidx(); + cur.pos() = cur.lastpos(); + cur.bv().cursor() = cur; break; case LFUN_LINE_BEGIN: - case LFUN_WORD_BACKWARD: - case LFUN_WORD_LEFT: cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); + // fall through case LFUN_LINE_BEGIN_SELECT: - case LFUN_WORD_BACKWARD_SELECT: - case LFUN_WORD_LEFT_SELECT: cur.selHandle(act == LFUN_WORD_BACKWARD_SELECT || act == LFUN_WORD_LEFT_SELECT || act == LFUN_LINE_BEGIN_SELECT); @@ -754,12 +773,9 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } break; - case LFUN_WORD_FORWARD: - case LFUN_WORD_RIGHT: case LFUN_LINE_END: cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); - case LFUN_WORD_FORWARD_SELECT: - case LFUN_WORD_RIGHT_SELECT: + // fall through case LFUN_LINE_END_SELECT: cur.selHandle(act == LFUN_WORD_FORWARD_SELECT || act == LFUN_WORD_RIGHT_SELECT || @@ -795,11 +811,11 @@ 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()) { - FuncRequest cmd = FuncRequest(LFUN_CHAR_DELETE_FORWARD); + if (!cur.backspace(cmd.getArg(0) == "force")) { + FuncRequest cmd = FuncRequest(LFUN_CHAR_DELETE_FORWARD, "force"); cur.innerText()->dispatch(cur, cmd); } break; @@ -812,8 +828,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) else cur.recordUndoSelection(); // if the inset can not be removed from within, delete it - if (!cur.erase()) { - FuncRequest cmd = FuncRequest(LFUN_CHAR_DELETE_FORWARD); + if (!cur.erase(cmd.getArg(0) == "force")) { + FuncRequest cmd = FuncRequest(LFUN_CHAR_DELETE_FORWARD, "force"); cur.innerText()->dispatch(cur, cmd); } break; @@ -861,7 +877,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(); @@ -920,37 +936,37 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_FONT_BOLD: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "textbf"); else handleFont(cur, cmd.argument(), "mathbf"); break; case LFUN_FONT_BOLDSYMBOL: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "textbf"); else handleFont(cur, cmd.argument(), "boldsymbol"); break; case LFUN_FONT_SANS: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "textsf"); else handleFont(cur, cmd.argument(), "mathsf"); break; case LFUN_FONT_EMPH: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "emph"); else handleFont(cur, cmd.argument(), "mathcal"); break; case LFUN_FONT_ROMAN: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "textrm"); else handleFont(cur, cmd.argument(), "mathrm"); break; case LFUN_FONT_TYPEWRITER: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "texttt"); else handleFont(cur, cmd.argument(), "mathtt"); @@ -959,13 +975,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) handleFont(cur, cmd.argument(), "mathfrak"); break; case LFUN_FONT_ITAL: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) handleFont(cur, cmd.argument(), "textit"); else handleFont(cur, cmd.argument(), "mathit"); break; case LFUN_FONT_NOUN: - if (currentMode() <= TEXT_MODE) + if (currentMode() != MATH_MODE) // FIXME: should be "noun" handleFont(cur, cmd.argument(), "textsc"); else @@ -974,11 +990,11 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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 @@ -988,11 +1004,10 @@ 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) + if (currentMode() != Inset::MATH_MODE) cur.plainInsert(MathAtom(new InsetMathEnsureMath(buffer_))); else - cur.plainInsert(MathAtom(new InsetMathBox(buffer_, from_ascii("mbox")))); + cur.plainInsert(createInsetMath("text", buffer_)); cur.posBackward(); cur.pushBackward(*cur.nextInset()); cur.niceInsert(save_selection); @@ -1011,10 +1026,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_REGEXP_MODE: { - InsetMathHull * i = cur.inset().asInsetMath()->asHullInset(); - 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); @@ -1061,13 +1079,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; @@ -1106,20 +1130,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(); @@ -1213,7 +1265,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) string data; if (name == "ref") { InsetMathRef tmp(buffer_, name); - data = tmp.createDialogStr(to_utf8(name)); + data = tmp.createDialogStr(); cur.bv().showDialog(to_utf8(name), data); } else if (name == "mathspace") { cur.bv().showDialog(to_utf8(name)); @@ -1226,7 +1278,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) if (createInsetMath_fromDialogStr(cmd.argument(), ar)) { cur.recordUndoSelection(); cur.insert(ar); - cur.forceBufferUpdate(); + cur.forceBufferUpdate(); } else cur.undispatched(); break; @@ -1326,7 +1378,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; @@ -1348,6 +1399,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; @@ -1366,6 +1423,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 @@ -1381,14 +1446,33 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd, } 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; @@ -1411,7 +1495,7 @@ void InsetMathNest::edit(Cursor & cur, bool front, EntryDirection entry_from) Inset * InsetMathNest::editXY(Cursor & cur, int x, int y) { - int idx_min = 0; + int idx_min = -1; int dist_min = 1000000; for (idx_type i = 0, n = nargs(); i != n; ++i) { int const d = cell(i).dist(cur.bv(), x, y); @@ -1420,6 +1504,9 @@ Inset * InsetMathNest::editXY(Cursor & cur, int x, int y) idx_min = i; } } + if (idx_min == -1) + return this; + MathData & ar = cell(idx_min); cur.push(*this); cur.idx() = idx_min; @@ -1440,8 +1527,21 @@ 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; + } + } + + // set cursor after the inset if x is nearer to that position (bug 9748) + cur.moveToClosestEdge(cmd.x(), true); + bool do_selection = cmd.button() == mouse_button::button1 - && cmd.argument() == "region-select"; + && cmd.modifier() == ShiftModifier; bv.mouseSetCursor(cur, do_selection); if (cmd.button() == mouse_button::button1) { //lyxerr << "## lfunMousePress: setting cursor to: " << cur << endl; @@ -1455,7 +1555,7 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd) // cur.result().update(): don't overwrite previously set flags. cur.screenUpdateFlags(Update::Decoration | Update::FitCursor | cur.result().screenUpdate()); - } else if (cmd.button() == mouse_button::button2) { + } 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(); @@ -1473,16 +1573,32 @@ 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.realAnchor().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; } + + // set cursor after the inset if x is nearer to that position (bug 9748) + cur.moveToClosestEdge(cmd.x()); + + 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(); } @@ -1495,7 +1611,7 @@ void InsetMathNest::lfunMouseRelease(Cursor & cur, FuncRequest & cmd) cur.noScreenUpdate(); else { Cursor & bvcur = cur.bv().cursor(); - bvcur.setSelection(true); + bvcur.selection(true); } return; } @@ -1528,9 +1644,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)); @@ -1542,21 +1657,26 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) // remove the '\\' if (c == '\\') { cur.backspace(); - if (currentMode() <= InsetMath::TEXT_MODE) + if (currentMode() != InsetMath::MATH_MODE) cur.niceInsert(createInsetMath("textbackslash", buf)); else 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(buf))); - } else if (c == '%') { + } else if (c == '{' || c == '%') { + //using the saved selection as argument + InsetMathUnknown * p = cur.activeMacro(); + p->finalize(); + MathData sel(cur.buffer()); + asArray(p->selection(), sel); cur.backspace(); - cur.niceInsert(MathAtom(new InsetMathComment(buf))); + if (c == '{') + cur.niceInsert(MathAtom(new InsetMathBrace(sel))); + else + cur.niceInsert(MathAtom(new InsetMathComment(sel))); } else if (c == '#') { - LASSERT(cur.activeMacro(), /**/); + LASSERT(cur.activeMacro(), return false); cur.activeMacro()->setName(name + docstring(1, c)); } else { cur.backspace(); @@ -1593,6 +1713,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 @@ -1616,7 +1743,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)")); @@ -1625,7 +1752,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) // just clear selection on pressing the space bar if (cur.selection() && c == ' ') { - cur.setSelection(false); + cur.selection(false); return true; } @@ -1633,8 +1760,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; } @@ -1642,18 +1773,18 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) selClearOrDel(cur); if (c == '\n') { - if (currentMode() <= InsetMath::TEXT_MODE) + if (currentMode() != InsetMath::MATH_MODE) cur.insert(c); return true; } if (c == ' ') { - if (currentMode() <= InsetMath::TEXT_MODE) { + if (currentMode() != InsetMath::MATH_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 @@ -1687,7 +1818,26 @@ 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("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; @@ -1700,7 +1850,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) cur.niceInsert(createInsetMath("sim", buf)); return true; } - if (currentMode() == InsetMath::MATH_MODE && !isAsciiOrMathAlpha(c)) { + if (currentMode() == InsetMath::MATH_MODE && Encodings::isUnicodeTextOnly(c)) { MathAtom at = createInsetMath("text", buf); at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c))); cur.niceInsert(at); @@ -1915,43 +2065,6 @@ void InsetMathNest::completionPosAndDim(Cursor const & cur, int & x, int & 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) @@ -1966,12 +2079,12 @@ MathCompletionList::MathCompletionList(Cursor const & cur) } sort(locals.begin(), locals.end()); - if (globals.size() > 0) + if (!globals.empty()) return; // fill in global macros macros.clear(); - MacroTable::globalMacros().getMacroNames(macros); + MacroTable::globalMacros().getMacroNames(macros, false); //lyxerr << "Globals completion macros: "; for (it = macros.begin(); it != macros.end(); ++it) { //lyxerr << "\\" + *it << " "; @@ -1985,8 +2098,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")); @@ -2000,7 +2126,9 @@ MathCompletionList::MathCompletionList(Cursor const & cur) globals.push_back(from_ascii("\\sqrt")); globals.push_back(from_ascii("\\root")); globals.push_back(from_ascii("\\tabular")); + globals.push_back(from_ascii("\\sideset")); 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")); @@ -2030,12 +2158,24 @@ 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")); + globals.push_back(from_ascii("\\ensuremath")); 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" && !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()); @@ -2074,7 +2214,10 @@ std::string MathCompletionList::icon(size_t idx) const cmd = locals[idx]; // get the icon resource name by stripping the backslash - return "images/math/" + to_utf8(cmd.substr(1)) + ".png"; + 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;