X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathNest.cpp;h=f9c8813a01249ec1328b5e5b7428940f0fe25aae;hb=c8230ab0d0a919530c43c29395f4d9961498bf15;hp=4216145e8a00d568db08f3a54824b0668bdacb06;hpb=cb7094696095236b9a7133f41901e90aee767544;p=lyx.git diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp index 4216145e8a..f9c8813a01 100644 --- a/src/mathed/InsetMathNest.cpp +++ b/src/mathed/InsetMathNest.cpp @@ -32,8 +32,8 @@ #include "MathCompletionList.h" #include "MathData.h" #include "MathFactory.h" -#include "MathMacro.h" -#include "MathMacroArgument.h" +#include "InsetMathMacro.h" +#include "InsetMathMacroArgument.h" #include "MathParser.h" #include "MathStream.h" #include "MathSupport.h" @@ -48,6 +48,7 @@ #include "Encoding.h" #include "FuncRequest.h" #include "FuncStatus.h" +#include "LaTeXFeatures.h" #include "LyX.h" #include "LyXRC.h" #include "MetricsInfo.h" @@ -170,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); } } @@ -252,7 +255,7 @@ bool InsetMathNest::idxLast(Cursor & cur) const void InsetMathNest::dump() const { odocstringstream oss; - otexrowstream ots(oss, false); + otexrowstream ots(oss); WriteStream os(ots); os << "---------------------------------------------\n"; write(os); @@ -264,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); - } - } - } } @@ -406,6 +360,18 @@ void InsetMathNest::latex(otexstream & os, OutputParams const & runparams) const WriteStream wi(os, runparams.moving_arg, true, 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)); @@ -571,7 +537,7 @@ 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")); @@ -630,21 +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): @@ -657,18 +644,24 @@ 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); + || act == LFUN_CHAR_RIGHT + || act == LFUN_WORD_RIGHT_SELECT + || act == LFUN_WORD_RIGHT); if (lyxrc.visual_cursor || !cur.reverseDirectionNeeded()) forward = right; else @@ -684,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); @@ -695,10 +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(); @@ -706,8 +703,10 @@ 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: @@ -717,7 +716,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) } // 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; @@ -735,38 +735,24 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MOUSE_DOUBLE: case LFUN_WORD_SELECT: cur.pos() = 0; - cur.resetAnchor(); - cur.selection(true); + cur.bv().mouseSetCursor(cur); cur.pos() = cur.lastpos(); - cur.bv().cursor() = cur; + cur.bv().mouseSetCursor(cur, true); break; case LFUN_MOUSE_TRIPLE: cur.idx() = 0; cur.pos() = 0; - cur.resetAnchor(); - cur.selection(true); + cur.bv().mouseSetCursor(cur); cur.idx() = cur.lastidx(); cur.pos() = cur.lastpos(); - cur.bv().cursor() = cur; - break; - - case LFUN_PARAGRAPH_UP: - case LFUN_PARAGRAPH_DOWN: - cur.screenUpdateFlags(Update::Decoration | Update::FitCursor); - // fall through - case LFUN_PARAGRAPH_UP_SELECT: - case LFUN_PARAGRAPH_DOWN_SELECT: + cur.bv().mouseSetCursor(cur, true); 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); @@ -785,13 +771,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); // fall through - case LFUN_WORD_FORWARD_SELECT: - case LFUN_WORD_RIGHT_SELECT: case LFUN_LINE_END_SELECT: cur.selHandle(act == LFUN_WORD_FORWARD_SELECT || act == LFUN_WORD_RIGHT_SELECT || @@ -830,8 +812,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) 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; @@ -844,8 +826,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; @@ -952,37 +934,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"); @@ -991,13 +973,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 @@ -1020,7 +1002,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) cur.macroModeClose(); docstring const save_selection = grabAndEraseSelection(cur); selClearOrDel(cur); - if (currentMode() <= Inset::TEXT_MODE) + if (currentMode() != Inset::MATH_MODE) cur.plainInsert(MathAtom(new InsetMathEnsureMath(buffer_))); else cur.plainInsert(createInsetMath("text", buffer_)); @@ -1224,7 +1206,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd) bool fold = act == LFUN_MATH_MACRO_FOLD; bool found = findMacroToFoldUnfold(it, fold); if (found) { - MathMacro * macro = it.nextInset()->asInsetMath()->asMacro(); + InsetMathMacro * macro = it.nextInset()->asInsetMath()->asMacro(); cur.recordUndoInset(); if (fold) macro->fold(cur); @@ -1320,7 +1302,7 @@ bool InsetMathNest::findMacroToFoldUnfold(Cursor & it, bool fold) const { // go backward through the current cell Inset * inset = it.nextInset(); while (inset && inset->asInsetMath()) { - MathMacro * macro = inset->asInsetMath()->asMacro(); + InsetMathMacro * macro = inset->asInsetMath()->asMacro(); if (macro) { // found the an macro to open/close? if (macro->folded() != fold) @@ -1511,7 +1493,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); @@ -1520,6 +1502,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; @@ -1549,6 +1534,10 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd) 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.modifier() == ShiftModifier; bv.mouseSetCursor(cur, do_selection); @@ -1593,6 +1582,9 @@ void InsetMathNest::lfunMouseMotion(Cursor & cur, FuncRequest & cmd) 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 @@ -1645,7 +1637,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c) cur.backspace(); int n = c - '0'; if (n >= 1 && n <= 9) - cur.insert(new MathMacroArgument(n)); + cur.insert(new InsetMathMacroArgument(n)); return true; } @@ -1663,7 +1655,7 @@ 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)); @@ -1779,13 +1771,13 @@ 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 @@ -2071,43 +2063,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)