X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fmath_nestinset.C;h=79d058907e3ce0f105bca9010f9d95b3ddebe3d4;hb=183239b7def8ca0e51432f2d88891d4b9f055953;hp=f5096870ad0b2b56c914a2b72f80a16e5156efa7;hpb=302a00b035d825ac038970d7bf768ada9d278be9;p=lyx.git diff --git a/src/mathed/math_nestinset.C b/src/mathed/math_nestinset.C index f5096870ad..79d058907e 100644 --- a/src/mathed/math_nestinset.C +++ b/src/mathed/math_nestinset.C @@ -13,39 +13,67 @@ #include "math_nestinset.h" #include "math_arrayinset.h" +#include "math_braceinset.h" +#include "math_commentinset.h" #include "math_data.h" #include "math_deliminset.h" #include "math_factory.h" #include "math_hullinset.h" #include "math_mathmlstream.h" +#include "math_macroarg.h" +#include "math_mboxinset.h" #include "math_parser.h" +#include "math_scriptinset.h" #include "math_spaceinset.h" +#include "math_symbolinset.h" #include "math_support.h" -#include "math_mboxinset.h" +#include "math_unknowninset.h" #include "BufferView.h" +#include "CutAndPaste.h" +#include "FuncStatus.h" +#include "LColor.h" #include "bufferview_funcs.h" #include "cursor.h" #include "debug.h" #include "dispatchresult.h" #include "funcrequest.h" #include "gettext.h" -#include "LColor.h" +#include "outputparams.h" #include "undo.h" -#include "support/std_sstream.h" #include "support/lstrings.h" #include "frontends/Dialogs.h" #include "frontends/LyXView.h" #include "frontends/Painter.h" +#include + +using lyx::cap::copySelection; +using lyx::cap::grabAndEraseSelection; +using lyx::cap::cutSelection; +using lyx::cap::pasteSelection; +using lyx::cap::replaceSelection; +using lyx::cap::selClearOrDel; using std::endl; using std::string; using std::istringstream; + +namespace { + +// local global +int first_x; +int first_y; + +} // namespace anon + + + + MathNestInset::MathNestInset(idx_type nargs) : cells_(nargs), lock_(false) {} @@ -69,26 +97,18 @@ MathArray const & MathNestInset::cell(idx_type i) const } -void MathNestInset::getCursorPos(CursorSlice const & cur, - int & x, int & y) const +void MathNestInset::getCursorPos(LCursor const & cur, int & x, int & y) const { - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); + BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); MathArray const & ar = cur.cell(); x = ar.xo() + ar.pos2x(cur.pos()); - y = ar.yo(); + y = ar.yo() + cur.bv().top_y(); // move cursor visually into empty cells ("blue rectangles"); if (cur.cell().empty()) x += 2; } -void MathNestInset::substitute(MathMacro const & m) -{ - for (idx_type i = 0; i < nargs(); ++i) - cell(i).substitute(m); -} - - void MathNestInset::metrics(MetricsInfo const & mi) const { MetricsInfo m = mi; @@ -99,7 +119,7 @@ void MathNestInset::metrics(MetricsInfo const & mi) const bool MathNestInset::idxNext(LCursor & cur) const { - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); + BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); if (cur.idx() == cur.lastidx()) return false; ++cur.idx(); @@ -116,7 +136,7 @@ bool MathNestInset::idxRight(LCursor & cur) const bool MathNestInset::idxPrev(LCursor & cur) const { - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); + BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); if (cur.idx() == 0) return false; --cur.idx(); @@ -133,7 +153,7 @@ bool MathNestInset::idxLeft(LCursor & cur) const bool MathNestInset::idxFirst(LCursor & cur) const { - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); + BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); if (nargs() == 0) return false; cur.idx() = 0; @@ -144,7 +164,7 @@ bool MathNestInset::idxFirst(LCursor & cur) const bool MathNestInset::idxLast(LCursor & cur) const { - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); + BOOST_ASSERT(ptr_cmp(&cur.inset(), this)); if (nargs() == 0) return false; cur.idx() = cur.lastidx(); @@ -153,26 +173,6 @@ bool MathNestInset::idxLast(LCursor & cur) const } -bool MathNestInset::idxHome(LCursor & cur) const -{ - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); - if (cur.pos() == 0) - return false; - cur.pos() = 0; - return true; -} - - -bool MathNestInset::idxEnd(LCursor & cur) const -{ - BOOST_ASSERT(ptr_cmp(cur.inset(), this)); - if (cur.lastpos() == cur.lastpos()) - return false; - cur.pos() = cur.lastpos(); - return true; -} - - void MathNestInset::dump() const { WriteStream os(lyxerr); @@ -185,36 +185,42 @@ void MathNestInset::dump() const } -//void MathNestInset::draw(PainterInfo & pi, int x, int y) const -void MathNestInset::draw(PainterInfo &, int, int) const +void MathNestInset::draw(PainterInfo & pi, int x, int y) const { #if 0 if (lock_) pi.pain.fillRectangle(x, y - ascent(), width(), height(), LColor::mathlockbg); #endif + setPosCache(pi, x, y); } void MathNestInset::drawSelection(PainterInfo & pi, int x, int y) const { + // FIXME: hack to get position cache warm + draw(pi, x, y); + // this should use the x/y values given, not the cached values LCursor & cur = pi.base.bv->cursor(); if (!cur.selection()) return; - if (!ptr_cmp(cur.inset(), this)) + if (!ptr_cmp(&cur.inset(), this)) return; - CursorSlice & s1 = cur.selBegin(); - CursorSlice & s2 = cur.selEnd(); + CursorSlice s1 = cur.selBegin(); + CursorSlice s2 = cur.selEnd(); + //lyxerr << "MathNestInset::drawing selection: " + // << " s1: " << s1 << " s2: " << s2 << endl; if (s1.idx() == s2.idx()) { - MathArray const & c = s1.cell(); - lyxerr << "###### c.xo(): " << c.xo() << " c.yo(): " << c.yo() << endl; + MathArray const & c = cell(s1.idx()); int x1 = c.xo() + c.pos2x(s1.pos()); int y1 = c.yo() - c.ascent(); int x2 = c.xo() + c.pos2x(s2.pos()); int y2 = c.yo() + c.descent(); - //pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::selection); - pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::red); + pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::selection); + //lyxerr << "MathNestInset::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())) { @@ -223,8 +229,7 @@ void MathNestInset::drawSelection(PainterInfo & pi, int x, int y) const int y1 = c.yo() - c.ascent(); int x2 = c.xo() + c.width(); int y2 = c.yo() + c.descent(); - //pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::selection); - pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::red); + pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::selection); } } } @@ -304,9 +309,44 @@ void MathNestInset::normalize(NormalStream & os) const } -void MathNestInset::notifyCursorLeaves(idx_type idx) +int MathNestInset::latex(Buffer const &, std::ostream & os, + OutputParams const & runparams) const { - cell(idx).notifyCursorLeaves(); + WriteStream wi(os, runparams.moving_arg, true); + write(wi); + return wi.line(); +} + + +void MathNestInset::notifyCursorLeaves(LCursor & /*cur*/) +{ +#ifdef WITH_WARNINGS +#warning look here +#endif +#if 0 + MathArray & ar = cur.cell(); + // remove base-only "scripts" + for (pos_type i = 0; i + 1 < ar.size(); ++i) { + MathScriptInset * p = operator[](i).nucleus()->asScriptInset(); + if (p && p->nargs() == 1) { + MathArray ar = p->nuc(); + erase(i); + insert(i, ar); + cur.adjust(i, ar.size() - 1); + } + } + + // glue adjacent font insets of the same kind + for (pos_type i = 0; i + 1 < size(); ++i) { + MathFontInset * p = operator[](i).nucleus()->asFontInset(); + MathFontInset const * q = operator[](i + 1)->asFontInset(); + if (p && q && p->name() == q->name()) { + p->cell(0).append(q->cell(0)); + erase(i + 1); + cur.adjust(i, -1); + } + } +#endif } @@ -315,9 +355,9 @@ void MathNestInset::handleFont { // this whole function is a hack and won't work for incremental font // changes... - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); - if (cur.inset()->asMathInset()->name() == font) + if (cur.inset().asMathInset()->name() == font) cur.handleFont(font); else { cur.handleNest(createMathInset(font)); @@ -328,7 +368,7 @@ void MathNestInset::handleFont void MathNestInset::handleFont2(LCursor & cur, string const & arg) { - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); LyXFont font; bool b; bv_funcs::string2font(arg, font, b); @@ -340,237 +380,254 @@ void MathNestInset::handleFont2(LCursor & cur, string const & arg) } -DispatchResult -MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd) +void MathNestInset::doDispatch(LCursor & cur, FuncRequest & cmd) { - lyxerr << "*** MathNestInset: request: " << cmd << std::endl; - //lyxerr << "InsetFormulaBase::localDispatch: act: " << cmd.action - // << " arg: '" << cmd.argument - // << "' x: '" << cmd.x - // << " y: '" << cmd.y - // << "' button: " << cmd.button() << endl; + //lyxerr << "MathNestInset: request: " << cmd << std::endl; + //CursorSlice sl = cur.current(); switch (cmd.action) { - case LFUN_PASTE: - if (!cmd.argument.empty()) { - MathArray ar; - mathed_parse_cell(ar, cmd.argument); - cur.cell().insert(cur.pos(), ar); - cur.pos() += ar.size(); - } - return DispatchResult(true, true); -/* case LFUN_PASTE: { + recordUndo(cur); + cur.message(_("Paste")); + replaceSelection(cur); size_t n = 0; - istringstream is(cmd.argument.c_str()); + istringstream is(cmd.argument); is >> n; - if (was_macro) - cur.macroModeClose(); - //recordUndo(cur, Undo::ATOMIC); - cur.selPaste(n); - return DispatchResult(true, true); + pasteSelection(cur, n); + cur.clearSelection(); // bug 393 + cur.bv().switchKeyMap(); + finishUndo(); + break; } -*/ - case LFUN_PASTESELECTION: - return dispatch(cur, FuncRequest(LFUN_PASTE, cur.bv().getClipboard())); + case LFUN_CUT: + cutSelection(cur, true, true); + cur.message(_("Cut")); + break; + + case LFUN_COPY: + copySelection(cur); + cur.message(_("Copy")); + break; case LFUN_MOUSE_PRESS: - if (cmd.button() == mouse_button::button2) - return priv_dispatch(cur, FuncRequest(LFUN_PASTESELECTION)); - return DispatchResult(false); + lfunMousePress(cur, cmd); + break; + + case LFUN_MOUSE_MOTION: + lfunMouseMotion(cur, cmd); + break; + + case LFUN_MOUSE_RELEASE: + lfunMouseRelease(cur, cmd); + break; + + case LFUN_FINISHED_LEFT: + cur.bv().cursor() = cur; + break; + + case LFUN_FINISHED_RIGHT: + ++cur.pos(); + cur.bv().cursor() = cur; + break; + + case LFUN_FINISHED_UP: + cur.bv().cursor() = cur; + break; + + case LFUN_FINISHED_DOWN: + cur.bv().cursor() = cur; + break; case LFUN_RIGHTSEL: - cur.selection() = true; // fall through... case LFUN_RIGHT: - return cur.right() ? - DispatchResult(true, true) : DispatchResult(false, FINISHED_RIGHT); - //lyxerr << "calling scroll 20" << endl; - //scroll(&cur.bv(), 20); - // write something to the minibuffer - //cur.bv().owner()->message(cur.info()); + cur.selHandle(cmd.action == LFUN_RIGHTSEL); + 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_RIGHT); + break; case LFUN_LEFTSEL: - cur.selection() = true; // fall through case LFUN_LEFT: - return cur.left() ? - DispatchResult(true, true) : DispatchResult(false, FINISHED); + cur.selHandle(cmd.action == LFUN_LEFTSEL); + cur.autocorrect() = false; + 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_LEFT); + break; case LFUN_UPSEL: - cur.selection() = true; // fall through case LFUN_UP: - return cur.up() ? - DispatchResult(true, true) : DispatchResult(false, FINISHED_UP); + cur.selHandle(cmd.action == LFUN_UPSEL); + if (!cur.up()) + cmd = FuncRequest(LFUN_FINISHED_UP); + break; case LFUN_DOWNSEL: - cur.selection() = true; // fall through case LFUN_DOWN: - return cur.down() ? - DispatchResult(true, true) : DispatchResult(false, FINISHED_DOWN); + cur.selHandle(cmd.action == LFUN_DOWNSEL); + if (!cur.down()) + cmd = FuncRequest(LFUN_FINISHED_DOWN); + break; + case LFUN_MOUSE_DOUBLE: + case LFUN_MOUSE_TRIPLE: case LFUN_WORDSEL: - cur.home(); + cur.pos() = 0; + cur.idx() = 0; + cur.resetAnchor(); cur.selection() = true; - cur.end(); - return DispatchResult(true, true); + cur.pos() = cur.lastpos(); + cur.idx() = cur.lastidx(); + break; case LFUN_UP_PARAGRAPHSEL: case LFUN_UP_PARAGRAPH: case LFUN_DOWN_PARAGRAPHSEL: case LFUN_DOWN_PARAGRAPH: - return DispatchResult(true, FINISHED); + break; case LFUN_HOMESEL: - case LFUN_WORDLEFTSEL: - cur.selection() = true; // fall through case LFUN_HOME: + case LFUN_WORDLEFTSEL: case LFUN_WORDLEFT: - return cur.home() - ? DispatchResult(true, true) : DispatchResult(true, FINISHED); + cur.selHandle(cmd.action == LFUN_WORDLEFTSEL || cmd.action == LFUN_HOMESEL); + cur.macroModeClose(); + if (cur.pos() != 0) { + cur.pos() = 0; + } else if (cur.col() != 0) { + cur.idx() -= cur.col(); + cur.pos() = 0; + } else if (cur.idx() != 0) { + cur.idx() = 0; + cur.pos() = 0; + } else { + cmd = FuncRequest(LFUN_FINISHED_LEFT); + } + break; - case LFUN_ENDSEL: case LFUN_WORDRIGHTSEL: - cur.selection() = true; // fall through - case LFUN_END: case LFUN_WORDRIGHT: - return cur.end() - ? DispatchResult(true, true) : DispatchResult(false, FINISHED_RIGHT); + case LFUN_ENDSEL: + case LFUN_END: + cur.selHandle(cmd.action == LFUN_WORDRIGHTSEL || cmd.action == LFUN_ENDSEL); + cur.macroModeClose(); + cur.clearTargetX(); + if (cur.pos() != cur.lastpos()) { + cur.pos() = cur.lastpos(); + } else if (cur.col() != cur.lastcol()) { + cur.idx() = cur.idx() - cur.col() + cur.lastcol(); + cur.pos() = cur.lastpos(); + } else if (cur.idx() != cur.lastidx()) { + cur.idx() = cur.lastidx(); + cur.pos() = cur.lastpos(); + } else { + cmd = FuncRequest(LFUN_FINISHED_RIGHT); + } + break; case LFUN_PRIORSEL: case LFUN_PRIOR: - case LFUN_BEGINNINGBUFSEL: - case LFUN_BEGINNINGBUF: - return DispatchResult(true, FINISHED); + cmd = FuncRequest(LFUN_FINISHED_LEFT); + break; case LFUN_NEXTSEL: case LFUN_NEXT: - case LFUN_ENDBUFSEL: - case LFUN_ENDBUF: - return DispatchResult(false, FINISHED_RIGHT); + cmd = FuncRequest(LFUN_FINISHED_RIGHT); + break; case LFUN_CELL_FORWARD: - cur.inset()->idxNext(cur); - return DispatchResult(true, true); + cur.inset().idxNext(cur); + break; case LFUN_CELL_BACKWARD: - cur.inset()->idxPrev(cur); - return DispatchResult(true, true); + cur.inset().idxPrev(cur); + break; case LFUN_DELETE_WORD_BACKWARD: case LFUN_BACKSPACE: - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); cur.backspace(); - return DispatchResult(true, true); + break; case LFUN_DELETE_WORD_FORWARD: case LFUN_DELETE: - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur); cur.erase(); - return DispatchResult(true, FINISHED); + cmd = FuncRequest(LFUN_FINISHED_LEFT); + break; case LFUN_ESCAPE: - if (!cur.selection()) - return DispatchResult(true, true); - cur.selClear(); - return DispatchResult(false); + if (cur.selection()) + cur.clearSelection(); + else + cmd = FuncRequest(LFUN_FINISHED_LEFT); + break; case LFUN_INSET_TOGGLE: - cur.lockToggle(); - return DispatchResult(true, true); + recordUndo(cur); + //lockToggle(); + if (cur.pos() != cur.lastpos()) { + // toggle previous inset ... + cur.nextAtom().nucleus()->lock(!cur.nextAtom()->lock()); + } else if (cur.popLeft() && cur.pos() != cur.lastpos()) { + // ... or enclosing inset if we are in the last inset position + cur.nextAtom().nucleus()->lock(!cur.nextAtom()->lock()); + ++cur.pos(); + } + break; case LFUN_SELFINSERT: - if (!cmd.argument.empty()) { - //recordUndo(cur, Undo::ATOMIC); - if (cmd.argument.size() == 1) { - if (cur.interpret(cmd.argument[0])) - return DispatchResult(true, true); - else - return DispatchResult(false, FINISHED_RIGHT); - } + recordUndo(cur); + if (cmd.argument.size() != 1) { cur.insert(cmd.argument); - } - return DispatchResult(false, FINISHED_RIGHT); - - -#if 0 -// -// this needs to be incorporated -// - //lyxerr << "InsetFormulaBase::localDispatch: act: " << cmd.action - // << " arg: '" << cmd.argument - // << "' x: '" << cmd.x - // << " y: '" << cmd.y - // << "' button: " << cmd.button() << endl; - - // delete empty mathbox (LFUN_BACKSPACE and LFUN_DELETE) - bool remove_inset = false; - - switch (cmd.action) { - case LFUN_MOUSE_PRESS: - //lyxerr << "Mouse single press" << endl; - return lfunMousePress(cur, cmd); - case LFUN_MOUSE_MOTION: - //lyxerr << "Mouse motion" << endl; - return lfunMouseMotion(cur, cmd); - case LFUN_MOUSE_RELEASE: - //lyxerr << "Mouse single release" << endl; - return lfunMouseRelease(cur, cmd); - case LFUN_MOUSE_DOUBLE: - //lyxerr << "Mouse double" << endl; - return dispatch(cur, FuncRequest(LFUN_WORDSEL)); - default: break; - } - - DispatchResult result(true); - bool was_macro = cur.inMacroMode(); - - cur.normalize(); - cur.touch(); - - switch (cmd.action) { - - case LFUN_MATH_LIMITS: - //recordUndo(cur, Undo::ATOMIC); - cur.dispatch(cmd); + } + if (!interpret(cur, cmd.argument[0])) + cmd = FuncRequest(LFUN_FINISHED_RIGHT); break; -#endif - // case LFUN_GETXY: - // sprintf(dispatch_buffer, "%d %d",); - // DispatchResult= dispatch_buffer; - // break; + //case LFUN_GETXY: + // sprintf(dispatch_buffer, "%d %d",); + // break; + case LFUN_SETXY: { lyxerr << "LFUN_SETXY broken!" << endl; int x = 0; int y = 0; - istringstream is(cmd.argument.c_str()); + istringstream is(cmd.argument); is >> x >> y; cur.setScreenPos(x, y); - return DispatchResult(true, true); + break; } - case LFUN_CUT: - //recordUndo(cur, Undo::DELETE); - cur.selCut(); - return DispatchResult(true, true); - - case LFUN_COPY: - cur.selCopy(); - return DispatchResult(true, true); - - // Special casing for superscript in case of LyX handling // dead-keys: case LFUN_CIRCUMFLEX: if (cmd.argument.empty()) { // do superscript if LyX handles // deadkeys - //recordUndo(cur, Undo::ATOMIC); - cur.script(true); + recordUndo(cur, Undo::ATOMIC); + script(cur, true); } - return DispatchResult(true, true); + break; case LFUN_UMLAUT: case LFUN_ACUTE: @@ -586,72 +643,75 @@ MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_TIE: case LFUN_OGONEK: case LFUN_HUNG_UMLAUT: - return DispatchResult(true, true); + break; // Math fonts case LFUN_FREEFONT_APPLY: case LFUN_FREEFONT_UPDATE: handleFont2(cur, cmd.argument); - return DispatchResult(true, true); + break; case LFUN_BOLD: handleFont(cur, cmd.argument, "mathbf"); - return DispatchResult(true, true); + break; case LFUN_SANS: handleFont(cur, cmd.argument, "mathsf"); - return DispatchResult(true, true); + break; case LFUN_EMPH: handleFont(cur, cmd.argument, "mathcal"); - return DispatchResult(true, true); + break; case LFUN_ROMAN: handleFont(cur, cmd.argument, "mathrm"); - return DispatchResult(true, true); + break; case LFUN_CODE: handleFont(cur, cmd.argument, "texttt"); - return DispatchResult(true, true); + break; case LFUN_FRAK: handleFont(cur, cmd.argument, "mathfrak"); - return DispatchResult(true, true); + break; case LFUN_ITAL: handleFont(cur, cmd.argument, "mathit"); - return DispatchResult(true, true); + break; case LFUN_NOUN: handleFont(cur, cmd.argument, "mathbb"); - return DispatchResult(true, true); + break; //case LFUN_FREEFONT_APPLY: handleFont(cur, cmd.argument, "textrm"); - return DispatchResult(true, true); + break; case LFUN_DEFAULT: handleFont(cur, cmd.argument, "textnormal"); - return DispatchResult(true, true); + break; case LFUN_MATH_MODE: #if 1 + // ignore math-mode on when already in math mode + if (currentMode() == InsetBase::MATH_MODE && cmd.argument == "on") + break; cur.macroModeClose(); - cur.selClearOrDel(); + selClearOrDel(cur); cur.plainInsert(MathAtom(new MathMBoxInset(cur.bv()))); cur.posLeft(); - cur.pushLeft(cur.nextInset()); + cur.pushLeft(*cur.nextInset()); #else - if (cur.currentMode() == InsetBase::TEXT_MODE) + if (currentMode() == InsetBase::TEXT_MODE) { cur.niceInsert(MathAtom(new MathHullInset("simple"))); - else + cur.message(_("create new math text environment ($...$)")); + } else { handleFont(cur, cmd.argument, "textrm"); - //cur.owner()->message(_("math text mode toggled")); + cur.message(_("entered math text mode (textrm)")); + } #endif - return DispatchResult(true, true); + break; case LFUN_MATH_SIZE: #if 0 - if (!arg.empty()) { - //recordUndo(cur, Undo::ATOMIC); - cur.setSize(arg); - } + recordUndo(cur); + cur.setSize(arg); #endif - return DispatchResult(true, true); + break; case LFUN_INSERT_MATRIX: { - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); unsigned int m = 1; unsigned int n = 1; string v_align; @@ -665,11 +725,11 @@ MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd) v_align += 'c'; cur.niceInsert( MathAtom(new MathArrayInset("array", m, n, v_align[0], h_align))); - return DispatchResult(true, true); + break; } case LFUN_MATH_DELIM: { - //lyxerr << "formulabase::LFUN_MATH_DELIM, arg: '" << arg << "'" << endl; + lyxerr << "MathNestInset::LFUN_MATH_DELIM" << endl; string ls; string rs = lyx::support::split(cmd.argument, ls, ' '); // Reasonable default values @@ -677,48 +737,30 @@ MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd) ls = '('; if (rs.empty()) rs = ')'; - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); cur.handleNest(MathAtom(new MathDelimInset(ls, rs))); - return DispatchResult(true, true); + break; } case LFUN_SPACE_INSERT: case LFUN_MATH_SPACE: - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); cur.insert(MathAtom(new MathSpaceInset(","))); - return DispatchResult(true, true); - - case LFUN_UNDO: -#warning look here - //cur.bv().owner()->message(_("Invalid action in math mode!")); - return DispatchResult(true, true); + break; case LFUN_INSET_ERT: // interpret this as if a backslash was typed - //recordUndo(cur, Undo::ATOMIC); - cur.interpret('\\'); - return DispatchResult(true, true); - -#if 0 - case LFUN_BREAKPARAGRAPH: - case LFUN_BREAKPARAGRAPHKEEPLAYOUT: - case LFUN_BREAKPARAGRAPH_SKIP: - cmd.argument = "\n"; - //recordUndo(cur, Undo::ATOMIC); - cur.niceInsert(argument); - return DispatchResult(true, true); -#endif + recordUndo(cur, Undo::ATOMIC); + interpret(cur, '\\'); + break; // FIXME: We probably should swap parts of "math-insert" and "self-insert" // handling such that "self-insert" works on "arbitrary stuff" too, and // math-insert only handles special math things like "matrix". case LFUN_INSERT_MATH: - //recordUndo(cur, Undo::ATOMIC); + recordUndo(cur, Undo::ATOMIC); cur.niceInsert(cmd.argument); - return DispatchResult(true, true); - - case LFUN_DIALOG_SHOW: - return DispatchResult(false); + break; case LFUN_DIALOG_SHOW_NEW_INSET: { string const & name = cmd.argument; @@ -729,10 +771,8 @@ MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd) data = tmp.createDialogStr(name); } #endif - if (data.empty()) - return DispatchResult(false); cur.bv().owner()->getDialogs().show(name, data, 0); - return DispatchResult(true, true); + break; } case LFUN_INSET_APPLY: { @@ -741,63 +781,108 @@ MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd) if (base) { FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument); - return base->dispatch(cur, fr); + base->dispatch(cur, fr); + break; } MathArray ar; if (createMathInset_fromDialogStr(cmd.argument, ar)) { cur.insert(ar); - return DispatchResult(true, true); + break; } - return DispatchResult(false); + cur.undispatched(); + break; } -#warning look here -#if 0 + default: + MathDimInset::doDispatch(cur, cmd); + break; + } +} - case LFUN_WORD_REPLACE: - case LFUN_WORD_FIND: - return - searchForward(&cur.bv(), cmd.getArg(0), false, false) - ? DispatchResult(true, true) : DispatchResult(false); - case LFUN_INSERT_MATH: - case LFUN_INSERT_MATRIX: - case LFUN_MATH_DELIM: { - MathHullInset * f = new MathHullInset; - if (openNewInset(cur, f)) { - cur.inset()->dispatch(cur, FuncRequest(LFUN_MATH_MUTATE, "simple")); - cur.inset()->dispatch(cur, cmd); +bool MathNestInset::getStatus(LCursor & /*cur*/, FuncRequest const & cmd, + FuncStatus & flag) const +{ + // the font related toggles + //string tc = "mathnormal"; + bool ret = true; + switch (cmd.action) { +#if 0 + case LFUN_TABULAR_FEATURE: + // FIXME: check temporarily disabled + // valign code + char align = mathcursor::valign(); + if (align == '\0') { + enable = false; + break; } - return DispatchResult(true, true); - } - - cur.normalize(); - cur.touch(); + if (cmd.argument.empty()) { + flag.clear(); + break; + } + if (!contains("tcb", cmd.argument[0])) { + enable = false; + break; + } + flag.setOnOff(cmd.argument[0] == align); + break; + case LFUN_BOLD: + flag.setOnOff(tc == "mathbf"); + break; + case LFUN_SANS: + flag.setOnOff(tc == "mathsf"); + break; + case LFUN_EMPH: + flag.setOnOff(tc == "mathcal"); + break; + case LFUN_ROMAN: + flag.setOnOff(tc == "mathrm"); + break; + case LFUN_CODE: + flag.setOnOff(tc == "mathtt"); + break; + case LFUN_NOUN: + flag.setOnOff(tc == "mathbb"); + break; + case LFUN_DEFAULT: + flag.setOnOff(tc == "mathnormal"); + break; +#endif + case LFUN_MATH_MUTATE: + //flag.setOnOff(mathcursor::formula()->hullType() == cmd.argument); + flag.setOnOff(false); + break; - BOOST_ASSERT(cur.inMathed()); + // 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); + break; - if (result.dispatched()) { - revealCodes(cur); - cur.bv().stuffClipboard(cur.grabSelection()); - } else { - cur.releaseMathCursor(); - if (remove_inset) - cur.bv().owner()->dispatch(FuncRequest(LFUN_DELETE)); + default: + ret = false; + break; } + return ret; +} - return result; // original version -#endif - default: - return MathDimInset::priv_dispatch(cur, cmd); - } +void MathNestInset::edit(LCursor & cur, bool left) +{ + cur.push(*this); + cur.idx() = left ? 0 : cur.lastidx(); + cur.pos() = left ? 0 : cur.lastpos(); + cur.resetAnchor(); + lyxerr << "MathNestInset::edit, cur:\n" << cur << endl; } -void MathNestInset::edit(LCursor & cur, int x, int y) +InsetBase * MathNestInset::editXY(LCursor & cur, int x, int y) const { - lyxerr << "Called MathNestInset::edit with '" << x << ' ' << y << "'" << endl; - cur.push(this); int idx_min = 0; int dist_min = 1000000; for (idx_type i = 0; i < nargs(); ++i) { @@ -807,8 +892,8 @@ void MathNestInset::edit(LCursor & cur, int x, int y) idx_min = i; } } - MathArray & ar = cell(idx_min); - cur.push(this); + MathArray const & ar = cell(idx_min); + cur.push(const_cast(*this)); cur.idx() = idx_min; cur.pos() = ar.x2pos(x - ar.xo()); lyxerr << "found cell : " << idx_min << " pos: " << cur.pos() << endl; @@ -816,6 +901,260 @@ void MathNestInset::edit(LCursor & cur, int x, int y) // hit inside cell for (pos_type i = 0, n = ar.size(); i < n; ++i) if (ar[i]->covers(x, y)) - ar[i].nucleus()->edit(cur, x, y); + return ar[i].nucleus()->editXY(cur, x, y); + } + return const_cast(this); +} + + +void MathNestInset::lfunMousePress(LCursor & cur, FuncRequest & cmd) +{ + lyxerr << "lfunMousePress: buttons: " << cmd.button() << endl; + if (cmd.button() == mouse_button::button1) { + first_x = cmd.x; + first_y = cmd.y; + lyxerr << "lfunMousePress: setting cursor to: " << cur << endl; + cur.resetAnchor(); + cur.bv().cursor() = cur; + } + + if (cmd.button() == mouse_button::button2) { + cur.dispatch(FuncRequest(LFUN_PASTESELECTION)); + } +} + + +void MathNestInset::lfunMouseMotion(LCursor & cur, FuncRequest & cmd) +{ + // only select with button 1 + if (cmd.button() == mouse_button::button1) { + LCursor & bvcur = cur.bv().cursor(); + if (abs(cmd.x - first_x) + abs(cmd.y - first_y) > 4 + && bvcur.anchor_.hasPart(cur)) { + first_x = cmd.x; + first_y = cmd.y; + + bvcur.setCursor(cur); + bvcur.selection() = true; + } + } +} + + +void MathNestInset::lfunMouseRelease(LCursor & cur, FuncRequest & cmd) +{ + lyxerr << "lfunMouseRelease: buttons: " << cmd.button() << endl; + + if (cmd.button() == mouse_button::button1) { + //cur.bv().stuffClipboard(cur.grabSelection()); + return; + } + + if (cmd.button() == mouse_button::button2) { + MathArray ar; + asArray(cur.bv().getClipboard(), ar); + cur.clearSelection(); + cur.setScreenPos(cmd.x, cmd.y); + cur.insert(ar); + cur.bv().update(); + return; } + + if (cmd.button() == mouse_button::button3) { + // try to dispatch to enclosed insets first + cur.bv().owner()->getDialogs().show("mathpanel"); + return; + } + + cur.undispatched(); +} + + +bool MathNestInset::interpret(LCursor & cur, char c) +{ + lyxerr << "interpret 2: '" << c << "'" << endl; + cur.clearTargetX(); + + // handle macroMode + if (cur.inMacroMode()) { + string name = cur.macroName(); + + /// are we currently typing '#1' or '#2' or...? + if (name == "\\#") { + cur.backspace(); + int n = c - '0'; + if (n >= 1 && n <= 9) + cur.insert(new MathMacroArgument(n)); + return true; + } + + if (isalpha(c)) { + cur.activeMacro()->setName(name + c); + return true; + } + + // handle 'special char' macros + if (name == "\\") { + // remove the '\\' + if (c == '\\') { + cur.backspace(); + if (currentMode() == MathInset::TEXT_MODE) + cur.niceInsert(createMathInset("textbackslash")); + else + cur.niceInsert(createMathInset("backslash")); + } else if (c == '{') { + cur.backspace(); + cur.niceInsert(MathAtom(new MathBraceInset)); + } else if (c == '%') { + cur.backspace(); + cur.niceInsert(MathAtom(new MathCommentInset)); + } else if (c == '#') { + BOOST_ASSERT(cur.activeMacro()); + cur.activeMacro()->setName(name + c); + } else { + cur.backspace(); + cur.niceInsert(createMathInset(string(1, c))); + } + return true; + } + + // leave macro mode and try again if necessary + cur.macroModeClose(); + if (c == '{') + cur.niceInsert(MathAtom(new MathBraceInset)); + else if (c != ' ') + interpret(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 + + // just clear selection on pressing the space bar + if (cur.selection() && c == ' ') { + cur.selection() = false; + return true; + } + + selClearOrDel(cur); + + if (c == '\\') { + //lyxerr << "starting with macro" << endl; + cur.insert(MathAtom(new MathUnknownInset("\\", false))); + return true; + } + + if (c == '\n') { + if (currentMode() == MathInset::TEXT_MODE) + cur.insert(c); + return true; + } + + if (c == ' ') { + if (currentMode() == MathInset::TEXT_MODE) { + // insert spaces in text mode, + // but suppress direct insertion of two spaces in a row + // the still allows typing 'a' and deleting the 'a', but + // it is better than nothing... + if (!cur.pos() != 0 || cur.prevAtom()->getChar() != ' ') + cur.insert(c); + return true; + } + if (cur.pos() != 0 && cur.prevAtom()->asSpaceInset()) { + cur.prevAtom().nucleus()->asSpaceInset()->incSpace(); + return true; + } + if (cur.popRight()) + return true; + // if are at the very end, leave the formula + return cur.pos() != cur.lastpos(); + } + + if (c == '_') { + script(cur, false); + return true; + } + + if (c == '^') { + script(cur, true); + return true; + } + + if (c == '{' || c == '}' || c == '&' || c == '$' || c == '#' || c == '%') { + cur.niceInsert(createMathInset(string(1, c))); + return true; + } + + if (c == '~') { + cur.niceInsert(createMathInset("sim")); + return true; + } + + // try auto-correction + //if (autocorrect() && hasPrevAtom() && math_autocorrect(prevAtom(), c)) + // return true; + + // no special circumstances, so insert the character without any fuss + cur.insert(c); + cur.autocorrect() = true; + return true; +} + + +bool MathNestInset::script(LCursor & cur, bool up) +{ + // Hack to get \^ and \_ working + lyxerr << "handling script: up: " << up << endl; + if (cur.inMacroMode() && cur.macroName() == "\\") { + if (up) + cur.niceInsert(createMathInset("mathcircumflex")); + else + interpret(cur, '_'); + return true; + } + + cur.macroModeClose(); + string safe = grabAndEraseSelection(cur); + if (asScriptInset() && cur.idx() == 0) { + // we are in a nucleus of a script inset, move to _our_ script + MathScriptInset * inset = asScriptInset(); + lyxerr << " going to cell " << inset->idxOfScript(up) << endl; + inset->ensure(up); + cur.idx() = inset->idxOfScript(up); + cur.pos() = 0; + } else if (cur.pos() != 0 && cur.prevAtom()->asScriptInset()) { + --cur.pos(); + MathScriptInset * inset = cur.nextAtom().nucleus()->asScriptInset(); + cur.push(*inset); + cur.idx() = inset->idxOfScript(up); + cur.pos() = cur.lastpos(); + } else { + // convert the thing to our left to a scriptinset or create a new + // one if in the very first position of the array + if (cur.pos() == 0) { + lyxerr << "new scriptinset" << endl; + cur.insert(new MathScriptInset(up)); + } else { + lyxerr << "converting prev atom " << endl; + cur.prevAtom() = MathAtom(new MathScriptInset(cur.prevAtom(), up)); + } + --cur.pos(); + MathScriptInset * inset = cur.nextAtom().nucleus()->asScriptInset(); + cur.push(*inset); + cur.idx() = 1; + cur.pos() = 0; + } + lyxerr << "pasting 1: safe:\n" << safe << endl; + cur.paste(safe); + cur.resetAnchor(); + lyxerr << "pasting 2: safe:\n" << safe << endl; + return true; }