#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_parser.h"
+#include "math_scriptinset.h"
#include "math_spaceinset.h"
#include "math_support.h"
#include "math_mboxinset.h"
+#include "math_unknowninset.h"
#include "BufferView.h"
#include "bufferview_funcs.h"
}
-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);
}
-DispatchResult
-MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
{
lyxerr << "MathNestInset: request: " << cmd << std::endl;
+ //CursorSlice sl = cur.current();
switch (cmd.action) {
cur.cell().insert(cur.pos(), ar);
cur.pos() += ar.size();
}
- return DispatchResult(true, true);
+ break;
/*
case LFUN_PASTE: {
size_t n = 0;
cur.macroModeClose();
//recordUndo(cur, Undo::ATOMIC);
cur.selPaste(n);
- return DispatchResult(true, true);
+ break;
}
*/
case LFUN_PASTESELECTION:
- return dispatch(cur, FuncRequest(LFUN_PASTE, cur.bv().getClipboard()));
+ dispatch(cur, FuncRequest(LFUN_PASTE, cur.bv().getClipboard()));
+ break;
case LFUN_MOUSE_PRESS:
- return lfunMousePress(cur, cmd);
+ lfunMousePress(cur, cmd);
+ break;
+
case LFUN_MOUSE_MOTION:
- return lfunMouseMotion(cur, cmd);
+ lfunMouseMotion(cur, cmd);
+ break;
+
case LFUN_MOUSE_RELEASE:
- return lfunMouseRelease(cur, cmd);
+ lfunMouseRelease(cur, cmd);
+ break;
+
case LFUN_MOUSE_DOUBLE:
- return dispatch(cur, FuncRequest(LFUN_WORDSEL));
+ case LFUN_MOUSE_TRIPLE:
+ //lyxerr << "Mouse double" << endl;
+ //lyxerr << "Mouse triple" << endl;
+ dispatch(cur, FuncRequest(LFUN_WORDSEL));
+ 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:
+ //idxUpDown(cur, true);
+ cur.bv().cursor() = cur;
+ break;
+
+ case LFUN_FINISHED_DOWN:
+ //idxUpDown(cur, false);
+ cur.bv().cursor() = cur;
+ break;
case LFUN_RIGHTSEL:
case LFUN_RIGHT:
+ lyxerr << "mathnest RIGHT: from:\n" << cur << endl;
cur.selHandle(cmd.action == LFUN_RIGHTSEL);
- return cur.right() ?
- DispatchResult(true, true) : DispatchResult(false, FINISHED_RIGHT);
+ cur.autocorrect() = false;
+ cur.clearTargetX();
+ if (cur.inMacroMode())
+ cur.macroModeClose();
+ else 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
+ cur.dispatched(FINISHED_RIGHT);
+ lyxerr << "mathnest RIGHT: to:\n" << cur << endl;
+ break;
case LFUN_LEFTSEL:
case LFUN_LEFT:
cur.selHandle(cmd.action == LFUN_LEFTSEL);
- return cur.left() ?
- DispatchResult(true, true) : DispatchResult(false, FINISHED);
+ cur.autocorrect() = false;
+ cur.clearTargetX();
+ if (cur.inMacroMode())
+ cur.macroModeClose();
+ else 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
+ cur.dispatched(FINISHED_LEFT);
+ break;
case LFUN_UPSEL:
case LFUN_UP:
cur.selHandle(cmd.action == LFUN_UPSEL);
- return cur.up() ?
- DispatchResult(true, true) : DispatchResult(false, FINISHED_UP);
+ if (!cur.up())
+ cur.dispatched(FINISHED_UP);
+ break;
case LFUN_DOWNSEL:
case LFUN_DOWN:
cur.selHandle(cmd.action == LFUN_DOWNSEL);
- return cur.down() ?
- DispatchResult(true, true) : DispatchResult(false, FINISHED_DOWN);
+ if (!cur.down())
+ cur.dispatched(FINISHED_DOWN);
+ break;
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_HOME:
case LFUN_WORDLEFTSEL:
case LFUN_WORDLEFT:
- cur.selHandle(cmd.action == LFUN_WORDLEFTSEL);
- 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 {
+ cur.dispatched(FINISHED_LEFT);
+ }
+ break;
case LFUN_WORDRIGHTSEL:
case LFUN_WORDRIGHT:
- cur.selHandle(cmd.action == LFUN_WORDRIGHTSEL);
- return cur.end()
- ? DispatchResult(true, true) : DispatchResult(false, FINISHED_RIGHT);
-
- case LFUN_HOMESEL:
- case LFUN_HOME:
- cur.selHandle(cmd.action == LFUN_HOMESEL);
- return cur.home()
- ? DispatchResult(true, true) : DispatchResult(true, FINISHED);
-
case LFUN_ENDSEL:
case LFUN_END:
- cur.selHandle(cmd.action == LFUN_ENDSEL);
- return cur.end()
- ? DispatchResult(true, true) : DispatchResult(false, FINISHED_RIGHT);
+ 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 {
+ cur.dispatched(FINISHED_RIGHT);
+ }
+ break;
case LFUN_PRIORSEL:
case LFUN_PRIOR:
case LFUN_BEGINNINGBUFSEL:
case LFUN_BEGINNINGBUF:
- return DispatchResult(true, FINISHED);
+ cur.dispatched(FINISHED_LEFT);
+ break;
case LFUN_NEXTSEL:
case LFUN_NEXT:
case LFUN_ENDBUFSEL:
case LFUN_ENDBUF:
- return DispatchResult(false, FINISHED_RIGHT);
+ cur.dispatched(FINISHED_RIGHT);
+ break;
case LFUN_CELL_FORWARD:
cur.inset()->idxNext(cur);
- return DispatchResult(true, true);
+ break;
case LFUN_CELL_BACKWARD:
cur.inset()->idxPrev(cur);
- return DispatchResult(true, true);
+ break;
case LFUN_DELETE_WORD_BACKWARD:
case LFUN_BACKSPACE:
//recordUndo(cur, Undo::ATOMIC);
cur.backspace();
- return DispatchResult(true, true);
+ break;
case LFUN_DELETE_WORD_FORWARD:
case LFUN_DELETE:
//recordUndo(cur, Undo::ATOMIC);
cur.erase();
- return DispatchResult(true, FINISHED);
+ cur.dispatched(FINISHED_LEFT);
+ break;
case LFUN_ESCAPE:
- if (!cur.selection())
- return DispatchResult(true, true);
- cur.selClear();
- return DispatchResult(false);
+ if (cur.selection())
+ cur.selClear();
+ else
+ cur.dispatched(FINISHED_LEFT);
+ break;
case LFUN_INSET_TOGGLE:
- cur.lockToggle();
- return DispatchResult(true, true);
+ //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);
- }
+ if (cmd.argument.empty()) {
+ cur.dispatched(FINISHED_RIGHT);
+ break;
+ }
+ //recordUndo(cur, Undo::ATOMIC);
+ if (cmd.argument.size() != 1) {
cur.insert(cmd.argument);
+ break;
}
- return DispatchResult(false, FINISHED_RIGHT);
-
+ if (!interpret(cur, cmd.argument[0]))
+ cur.dispatched(FINISHED_RIGHT);
+ break;
#if 0
//
istringstream is(cmd.argument.c_str());
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);
+ break;
case LFUN_COPY:
cur.selCopy();
- return DispatchResult(true, true);
-
+ break;
// Special casing for superscript in case of LyX handling
// dead-keys:
// do superscript if LyX handles
// deadkeys
//recordUndo(cur, Undo::ATOMIC);
- cur.script(true);
+ script(cur, true);
}
- return DispatchResult(true, true);
+ break;
case LFUN_UMLAUT:
case LFUN_ACUTE:
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
cur.posLeft();
cur.pushLeft(cur.nextInset());
#else
- if (cur.currentMode() == InsetBase::TEXT_MODE)
+ if (currentMode() == InsetBase::TEXT_MODE)
cur.niceInsert(MathAtom(new MathHullInset("simple")));
else
handleFont(cur, cmd.argument, "textrm");
//cur.owner()->message(_("math text mode toggled"));
#endif
- return DispatchResult(true, true);
+ break;
case LFUN_MATH_SIZE:
#if 0
cur.setSize(arg);
}
#endif
- return DispatchResult(true, true);
+ break;
case LFUN_INSERT_MATRIX: {
//recordUndo(cur, Undo::ATOMIC);
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: {
rs = ')';
//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);
cur.insert(MathAtom(new MathSpaceInset(",")));
- return DispatchResult(true, true);
+ break;
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);
+ 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
case LFUN_INSERT_MATH:
//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;
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: {
InsetBase * base = cur.bv().owner()->getDialogs().getOpenInset(name);
if (base) {
- FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument);
- return base->dispatch(cur, fr);
+ base->dispatch(cur, FuncRequest(LFUN_INSET_MODIFY, cmd.argument));
+ 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
case LFUN_WORD_REPLACE:
case LFUN_WORD_FIND:
- return
- searchForward(&cur.bv(), cmd.getArg(0), false, false)
- ? DispatchResult(true, true) : DispatchResult(false);
+ if (!searchForward(&cur.bv(), cmd.getArg(0), false, false))
+ cur.undispatched();
+ break;
cur.normalize();
cur.touch();
revealCodes(cur);
cur.bv().stuffClipboard(cur.grabSelection());
} else {
- cur.releaseMathCursor();
if (remove_inset)
cur.bv().owner()->dispatch(FuncRequest(LFUN_DELETE));
}
-
- return result; // original version
+ break;
#endif
default:
- return MathDimInset::priv_dispatch(cur, cmd);
+ MathDimInset::priv_dispatch(cur, cmd);
+ break;
}
}
}
-void MathNestInset::edit(LCursor & cur, int x, int y)
+InsetBase * MathNestInset::editXY(LCursor & cur, int x, int y)
{
int idx_min = 0;
int dist_min = 1000000;
// 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 this;
}
-DispatchResult
-MathNestInset::lfunMouseRelease(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::lfunMouseRelease(LCursor & cur, FuncRequest const & cmd)
{
//lyxerr << "lfunMouseRelease: buttons: " << cmd.button() << endl;
if (cmd.button() == mouse_button::button1) {
// try to dispatch to enclosed insets first
//cur.bv().stuffClipboard(cur.grabSelection());
- return DispatchResult(true, true);
+ return;
}
if (cmd.button() == mouse_button::button2) {
cur.setScreenPos(cmd.x, cmd.y);
cur.insert(ar);
cur.bv().update();
- return DispatchResult(true, true);
+ return;
}
if (cmd.button() == mouse_button::button3) {
// try to dispatch to enclosed insets first
cur.bv().owner()->getDialogs().show("mathpanel");
- return DispatchResult(true, true);
+ return;
}
- return DispatchResult(false);
+ cur.undispatched();
}
-DispatchResult
-MathNestInset::lfunMousePress(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::lfunMousePress(LCursor & cur, FuncRequest const & cmd)
{
lyxerr << "lfunMousePress: buttons: " << cmd.button() << endl;
if (cmd.button() == mouse_button::button1) {
//cur.setScreenPos(cmd.x + xo_, cmd.y + yo_);
lyxerr << "lfunMousePress: setting cursor to: " << cur << endl;
cur.bv().cursor() = cur;
- return DispatchResult(true, true);
}
if (cmd.button() == mouse_button::button2) {
- return priv_dispatch(cur, FuncRequest(LFUN_PASTESELECTION));
- }
-
- if (cmd.button() == mouse_button::button3) {
- return DispatchResult(true, true);
+ priv_dispatch(cur, FuncRequest(LFUN_PASTESELECTION));
}
-
- return DispatchResult(true, true);
}
-DispatchResult
-MathNestInset::lfunMouseMotion(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::lfunMouseMotion(LCursor & cur, FuncRequest const & cmd)
{
// only select with button 1
if (cmd.button() != mouse_button::button1)
- return DispatchResult(true, true);
+ return;
if (abs(cmd.x - first_x) < 2 && abs(cmd.y - first_y) < 2)
- return DispatchResult(true, true);
+ return;
first_x = cmd.x;
first_y = cmd.y;
cur.selBegin();
//cur.setScreenPos(cmd.x + xo_, cmd.y + yo_);
- cur.bv().cursor().cursor_ = cur.cursor_;
- cur.bv().cursor().selection() = true;
- return DispatchResult(true, true);
+ cur.bv().cursor().setCursor(cur, true);
+}
+
+
+bool MathNestInset::interpret(LCursor & cur, char c)
+{
+ //lyxerr << "interpret 2: '" << c << "'" << endl;
+ cur.clearTargetX();
+ if (cur.inMacroArgMode()) {
+ cur.posLeft();
+ cur.plainErase();
+#warning FIXME
+#if 0
+ int n = c - '0';
+ MathMacroTemplate const * p = formula()->asMacroTemplate();
+ if (p && 1 <= n && n <= p->numargs())
+ cur.insert(MathAtom(new MathMacroArgument(c - '0')));
+ else {
+ cur.insert(createMathInset("#"));
+ interpret(cur, c); // try again
+ }
+#endif
+ return true;
+ }
+
+ // handle macroMode
+ if (cur.inMacroMode()) {
+ string name = cur.macroName();
+ //lyxerr << "interpret name: '" << name << "'" << endl;
+
+ if (isalpha(c)) {
+ cur.activeMacro()->setName(cur.activeMacro()->name() + c);
+ return true;
+ }
+
+ // handle 'special char' macros
+ if (name == "\\") {
+ // remove the '\\'
+ cur.backspace();
+ if (c == '\\') {
+ if (currentMode() == MathInset::TEXT_MODE)
+ cur.niceInsert(createMathInset("textbackslash"));
+ else
+ cur.niceInsert(createMathInset("backslash"));
+ } else if (c == '{') {
+ cur.niceInsert(MathAtom(new MathBraceInset));
+ } else {
+ 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 <space> 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;
+ }
+
+ cur.selClearOrDel();
+
+ 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 '<space>a<space>' 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 == '$') {
+ cur.niceInsert(createMathInset(string(1, c)));
+ return true;
+ }
+
+ if (c == '%') {
+ cur.niceInsert(MathAtom(new MathCommentInset));
+ 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 = cur.grabAndEraseSelection();
+ if (asScriptInset() && cur.idx() == 2) {
+ // we are in a nucleus of a script inset, move to _our_ script
+ asScriptInset()->ensure(up);
+ cur.idx() = up;
+ cur.pos() = 0;
+ } else if (cur.pos() != 0 && cur.prevAtom()->asScriptInset()) {
+ --cur.pos();
+ cur.nextAtom().nucleus()->asScriptInset()->ensure(up);
+ cur.push(cur.nextInset());
+ cur.idx() = up;
+ cur.pos() = cur.lastpos();
+ } else if (cur.pos() != 0) {
+ --cur.pos();
+ cur.cell()[cur.pos()] = MathAtom(new MathScriptInset(cur.nextAtom(), up));
+ cur.push(cur.nextInset());
+ cur.idx() = up;
+ cur.pos() = 0;
+ } else {
+ cur.plainInsert(MathAtom(new MathScriptInset(up)));
+ --cur.pos();
+ cur.nextAtom().nucleus()->asScriptInset()->ensure(up);
+ cur.push(cur.nextInset());
+ cur.idx() = up;
+ cur.pos() = 0;
+ }
+ cur.paste(safe);
+ return true;
}