]> git.lyx.org Git - lyx.git/blobdiff - src/text2.C
more cursor dispatch
[lyx.git] / src / text2.C
index 576f7670520f324fe85f4b4caa821652369753fe..e15775524e164ac99ef5fd351930390432dac074 100644 (file)
@@ -79,9 +79,9 @@ LyXText::LyXText(BufferView * bv, bool in_inset)
 {}
 
 
-void LyXText::init(BufferView * bview)
+void LyXText::init(BufferView * bv)
 {
-       bv_owner = bview;
+       bv_owner = bv;
 
        ParagraphList::iterator const beg = paragraphs().begin();
        ParagraphList::iterator const end = paragraphs().end();
@@ -94,8 +94,7 @@ void LyXText::init(BufferView * bview)
        current_font = getFont(beg, 0);
 
        redoParagraphs(beg, end);
-       setCursorIntern(0, 0);
-       selection.cursor = cursor;
+       bv->cursor().resetAnchor();
 
        updateCounters();
 }
@@ -214,38 +213,6 @@ void LyXText::setCharFont(
 }
 
 
-InsetOld * LyXText::getInset() const
-{
-       ParagraphList::iterator pit = cursorPar();
-       pos_type const pos = cursor.pos();
-
-       if (pos < pit->size() && pit->isInset(pos)) {
-               return pit->getInset(pos);
-       }
-       return 0;
-}
-
-
-bool LyXText::toggleInset()
-{
-       InsetOld * inset = getInset();
-       // is there an editable inset at cursor position?
-       if (!isEditableInset(inset))
-               return false;
-       //bv()->owner()->message(inset->editMessage());
-
-       // do we want to keep this?? (JMarc)
-       if (!isHighlyEditableInset(inset))
-               recUndo(cursor.par());
-
-       if (inset->isOpen())
-               inset->close();
-       else
-               inset->open();
-       return true;
-}
-
-
 // used in setLayout
 // Asger is not sure we want to do this...
 void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
@@ -268,19 +235,32 @@ void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
 }
 
 
+// return past-the-last paragraph influenced by a layout change on pit
+ParagraphList::iterator LyXText::undoSpan(ParagraphList::iterator pit)
+{
+       ParagraphList::iterator end = paragraphs().end();
+       ParagraphList::iterator nextpit = boost::next(pit);
+       if (nextpit == end)
+               return nextpit;
+       //because of parindents
+       if (!pit->getDepth())
+               return boost::next(nextpit);
+       //because of depth constrains
+       for (; nextpit != end; ++pit, ++nextpit) {
+               if (!pit->getDepth())
+                       break;
+       }
+       return nextpit;
+}
+
+
 ParagraphList::iterator
 LyXText::setLayout(ParagraphList::iterator start,
                   ParagraphList::iterator end,
                   string const & layout)
 {
-       ParagraphList::iterator undopit = end;
-       ParagraphList::iterator pars_end = paragraphs().end();
-
-       while (undopit != pars_end && undopit->getDepth())
-               ++undopit;
-       //because of parindets etc
-       if (undopit != pars_end)
-               ++undopit;
+       BOOST_ASSERT(start != end);
+       ParagraphList::iterator undopit = undoSpan(boost::prior(end));
        recUndo(parOffset(start), parOffset(undopit) - 1);
 
        BufferParams const & bufparams = bv()->buffer()->params();
@@ -310,7 +290,7 @@ void LyXText::setLayout(string const & layout)
                bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
                bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
                bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
-               InsetOld * inset = new InsetEnvironment(params, layout);
+               InsetBase * inset = new InsetEnvironment(params, layout);
                if (bv()->insertInset(inset)) {
                        //inset->edit(bv());
                        //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
@@ -319,8 +299,10 @@ void LyXText::setLayout(string const & layout)
                return;
        }
 
-       ParagraphList::iterator start = getPar(selStart().par());
-       ParagraphList::iterator end = boost::next(getPar(selEnd().par()));
+       ParagraphList::iterator start =
+               getPar(bv()->cursor().selBegin().par());
+       ParagraphList::iterator end =
+               boost::next(getPar(bv()->cursor().selEnd().par()));
        ParagraphList::iterator endpit = setLayout(start, end, layout);
 
        redoParagraphs(start, endpit);
@@ -335,12 +317,12 @@ void getSelectionSpan(LyXText & text,
        ParagraphList::iterator & beg,
        ParagraphList::iterator & end)
 {
-       if (!text.selection.set()) {
+       if (!text.bv()->cursor().selection()) {
                beg = text.cursorPar();
                end = boost::next(beg);
        } else {
-               beg = text.getPar(text.selStart());
-               end = boost::next(text.getPar(text.selEnd()));
+               beg = text.getPar(text.bv()->cursor().selBegin());
+               end = boost::next(text.getPar(text.bv()->cursor().selEnd()));
        }
 }
 
@@ -410,11 +392,12 @@ void LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type)
 // set font over selection and make a total rebreak of those paragraphs
 void LyXText::setFont(LyXFont const & font, bool toggleall)
 {
+       LCursor & cur = bv()->cursor();
        // if there is no selection just set the current_font
-       if (!selection.set()) {
+       if (!cur.selection()) {
                // Determine basis font
                LyXFont layoutfont;
-               if (cursor.pos() < cursorPar()->beginOfBody())
+               if (cursor().pos() < cursorPar()->beginOfBody())
                        layoutfont = getLabelFont(cursorPar());
                else
                        layoutfont = getLayoutFont(cursorPar());
@@ -434,14 +417,14 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
        }
 
        // ok we have a selection.
-       recUndo(selStart().par(), selEnd().par());
+       recUndo(cur.selBegin().par(), cur.selEnd().par());
        freezeUndo();
 
-       ParagraphList::iterator beg = getPar(selStart().par());
-       ParagraphList::iterator end = getPar(selEnd().par());
+       ParagraphList::iterator beg = getPar(cur.selBegin().par());
+       ParagraphList::iterator end = getPar(cur.selEnd().par());
        
-       PosIterator pos(&paragraphs(), beg, selStart().pos());
-       PosIterator posend(&paragraphs(), end, selEnd().pos());
+       PosIterator pos(&paragraphs(), beg, cur.selBegin().pos());
+       PosIterator posend(&paragraphs(), end, cur.selEnd().pos());
 
        BufferParams const & params = bv()->buffer()->params();
 
@@ -457,40 +440,20 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
 }
 
 
-// important for the screen
-
-
 // the cursor set functions have a special mechanism. When they
-// realize, that you left an empty paragraph, they will delete it.
-
-// need the selection cursor:
-void LyXText::setSelection()
-{
-       TextCursor::setSelection();
-}
-
-
-void LyXText::clearSelection()
-{
-       TextCursor::clearSelection();
-
-       // reset this in the bv()!
-       if (bv() && bv()->text())
-               bv()->unsetXSel();
-}
-
+// realize you left an empty paragraph, they will delete it.
 
 void LyXText::cursorHome()
 {
        ParagraphList::iterator cpit = cursorPar();
-       setCursor(cpit, cpit->getRow(cursor.pos())->pos());
+       setCursor(cpit, cpit->getRow(cursor().pos())->pos());
 }
 
 
 void LyXText::cursorEnd()
 {
        ParagraphList::iterator cpit = cursorPar();
-       pos_type end = cpit->getRow(cursor.pos())->endpos();
+       pos_type end = cpit->getRow(cursor().pos())->endpos();
        // if not on the last row of the par, put the cursor before
        // the final space
        setCursor(cpit, end == cpit->size() ? end : end - 1);
@@ -524,7 +487,7 @@ void LyXText::toggleFree(LyXFont const & font, bool toggleall)
        // Try implicit word selection
        // If there is a change in the language the implicit word selection
        // is disabled.
-       LyXCursor resetCursor = cursor;
+       CursorSlice resetCursor = cursor();
        bool implicitSelection =
                font.language() == ignore_language
                && font.number() == LyXFont::IGNORE
@@ -536,37 +499,38 @@ void LyXText::toggleFree(LyXFont const & font, bool toggleall)
        // Implicit selections are cleared afterwards
        //and cursor is set to the original position.
        if (implicitSelection) {
-               clearSelection();
-               cursor = resetCursor;
-               selection.cursor = cursor;
+               bv()->cursor().clearSelection();
+               cursor() = resetCursor;
+               bv()->cursor().resetAnchor();
        }
 }
 
 
 string LyXText::getStringToIndex()
 {
+       LCursor & cur = bv()->cursor();
        // Try implicit word selection
        // If there is a change in the language the implicit word selection
        // is disabled.
-       LyXCursor const reset_cursor = cursor;
+       CursorSlice const reset_cursor = cursor();
        bool const implicitSelection =
                selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
 
        string idxstring;
-       if (!selection.set())
+       if (!cur.selection())
                bv()->owner()->message(_("Nothing to index!"));
-       else if (selStart().par() != selEnd().par())
+       else if (cur.selBegin().par() != cur.selEnd().par())
                bv()->owner()->message(_("Cannot index more than one paragraph!"));
        else
                idxstring = selectionAsString(*bv()->buffer(), false);
 
        // Reset cursors to their original position.
-       cursor = reset_cursor;
-       selection.cursor = cursor;
+       cursor() = reset_cursor;
+       cur.resetAnchor();
 
        // Clear the implicit selection.
        if (implicitSelection)
-               clearSelection();
+               cur.clearSelection();
 
        return idxstring;
 }
@@ -581,22 +545,15 @@ string LyXText::getStringToIndex()
 void LyXText::setParagraph(Spacing const & spacing, LyXAlignment align,
        string const & labelwidthstring, bool noindent)
 {
+       LCursor & cur = bv()->cursor();
        // make sure that the depth behind the selection are restored, too
-       ParagraphList::iterator endpit = boost::next(getPar(selEnd()));
-       ParagraphList::iterator pars_end = paragraphs().end();
-
-       while (endpit != pars_end && endpit->getDepth())
-               ++endpit;
-       // because of parindents etc.
-       if (endpit != pars_end)
-               ++endpit;
+       ParagraphList::iterator undopit = undoSpan(getPar(cur.selEnd()));
+       recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
 
-       recUndo(selStart().par(), parOffset(endpit) - 1);
+       ParagraphList::reverse_iterator pit(getPar(cur.selEnd().par()));
+       ParagraphList::reverse_iterator beg(getPar(cur.selBegin().par()));
 
-       ParagraphList::reverse_iterator pit(getPar(selEnd().par()));
-       ParagraphList::reverse_iterator beg(getPar(selStart().par()));
-
-       for (++beg; pit != beg; ++pit) {
+       for (--pit; pit != beg; ++pit) {
                ParagraphParameters & params = pit->params();
                params.spacing(spacing);
 
@@ -615,7 +572,7 @@ void LyXText::setParagraph(Spacing const & spacing, LyXAlignment align,
                params.noindent(noindent);
        }
 
-       redoParagraphs(getPar(selStart()), endpit);
+       redoParagraphs(getPar(cur.selBegin()), undopit);
 }
 
 
@@ -828,14 +785,14 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
                if (layout->labeltype == LABEL_SENSITIVE) {
                        ParagraphList::iterator end = paragraphs().end();
                        ParagraphList::iterator tmppit = pit;
-                       InsetOld * in = 0;
+                       InsetBase * in = 0;
                        bool isOK = false;
                        while (tmppit != end && tmppit->inInset()
                               // the single '=' is intended below
                               && (in = tmppit->inInset()->owner()))
                        {
-                               if (in->lyxCode() == InsetOld::FLOAT_CODE ||
-                                   in->lyxCode() == InsetOld::WRAP_CODE) {
+                               if (in->lyxCode() == InsetBase::FLOAT_CODE ||
+                                   in->lyxCode() == InsetBase::WRAP_CODE) {
                                        isOK = true;
                                        break;
                                } else {
@@ -850,9 +807,9 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
                        if (isOK) {
                                string type;
 
-                               if (in->lyxCode() == InsetOld::FLOAT_CODE)
+                               if (in->lyxCode() == InsetBase::FLOAT_CODE)
                                        type = static_cast<InsetFloat*>(in)->params().type;
-                               else if (in->lyxCode() == InsetOld::WRAP_CODE)
+                               else if (in->lyxCode() == InsetBase::WRAP_CODE)
                                        type = static_cast<InsetWrap*>(in)->params().type;
                                else
                                        BOOST_ASSERT(false);
@@ -908,14 +865,14 @@ void LyXText::updateCounters()
 }
 
 
-void LyXText::insertInset(InsetOld * inset)
+void LyXText::insertInset(InsetBase * inset)
 {
        if (!cursorPar()->insetAllowed(inset->lyxCode()))
                return;
 
-       recUndo(cursor.par());
+       recUndo(cursor().par());
        freezeUndo();
-       cursorPar()->insertInset(cursor.pos(), inset);
+       cursorPar()->insertInset(cursor().pos(), inset);
        // Just to rebreak and refresh correctly.
        // The character will not be inserted a second time
        insertChar(Paragraph::META_INSET);
@@ -932,6 +889,7 @@ void LyXText::insertInset(InsetOld * inset)
 
 void LyXText::cutSelection(bool doclear, bool realcut)
 {
+       LCursor & cur = bv()->cursor();
        // Stuff what we got on the clipboard. Even if there is no selection.
 
        // There is a problem with having the stuffing here in that the
@@ -943,39 +901,32 @@ void LyXText::cutSelection(bool doclear, bool realcut)
        bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
 
        // This doesn't make sense, if there is no selection
-       if (!selection.set())
+       if (!cur.selection())
                return;
 
-       // OK, we have a selection. This is always between selStart()
-       // and selEnd()
+       // OK, we have a selection. This is always between cur.selBegin()
+       // and cur.selEnd()
 
        // make sure that the depth behind the selection are restored, too
-       ParagraphList::iterator begpit = getPar(selStart().par());
-       ParagraphList::iterator endpit = getPar(selEnd().par());
-       ParagraphList::iterator undopit = boost::next(endpit);
-       ParagraphList::iterator pars_end = paragraphs().end();
-
-       while (undopit != pars_end && undopit->getDepth())
-               ++undopit;
-       //because of parindents etc.
-       if (undopit != pars_end)
-               ++undopit;
-       recUndo(selStart().par(), parOffset(undopit) - 1);
+       ParagraphList::iterator begpit = getPar(cur.selBegin().par());
+       ParagraphList::iterator endpit = getPar(cur.selEnd().par());
+       ParagraphList::iterator undopit = undoSpan(endpit);
+       recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
 
-       int endpos = selEnd().pos();
+       int endpos = cur.selEnd().pos();
 
        BufferParams const & bufparams = bv()->buffer()->params();
        boost::tie(endpit, endpos) = realcut ?
                CutAndPaste::cutSelection(bufparams,
                                          paragraphs(),
                                          begpit , endpit,
-                                         selStart().pos(), endpos,
+                                         cur.selBegin().pos(), endpos,
                                          bufparams.textclass,
                                          doclear)
                : CutAndPaste::eraseSelection(bufparams,
                                              paragraphs(),
                                              begpit, endpit,
-                                             selStart().pos(), endpos,
+                                             cur.selBegin().pos(), endpos,
                                              doclear);
        // sometimes necessary
        if (doclear)
@@ -985,49 +936,51 @@ void LyXText::cutSelection(bool doclear, bool realcut)
        // cutSelection can invalidate the cursor so we need to set
        // it anew. (Lgb)
        // we prefer the end for when tracking changes
-       cursor.pos(endpos);
-       cursor.par(parOffset(endpit));
+       cursor().pos(endpos);
+       cursor().par(parOffset(endpit));
 
        // need a valid cursor. (Lgb)
-       clearSelection();
+       cur.clearSelection();
        updateCounters();
 }
 
 
 void LyXText::copySelection()
 {
+       LCursor & cur = bv()->cursor();
        // stuff the selection onto the X clipboard, from an explicit copy request
        bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
 
        // this doesnt make sense, if there is no selection
-       if (!selection.set())
+       if (!cur.selection())
                return;
 
-       // ok we have a selection. This is always between selStart()
+       // ok we have a selection. This is always between cur.selBegin()
        // and sel_end cursor
 
        // copy behind a space if there is one
-       while (getPar(selStart())->size() > selStart().pos()
-              && getPar(selStart())->isLineSeparator(selStart().pos())
-              && (selStart().par() != selEnd().par()
-                  || selStart().pos() < selEnd().pos()))
-               selStart().pos(selStart().pos() + 1);
-
-       CutAndPaste::copySelection(getPar(selStart().par()),
-                                  getPar(selEnd().par()),
-                                  selStart().pos(), 
-                                  selEnd().pos(),
+       while (getPar(cur.selBegin())->size() > cur.selBegin().pos()
+              && getPar(cur.selBegin())->isLineSeparator(cur.selBegin().pos())
+              && (cur.selBegin().par() != cur.selEnd().par()
+                  || cur.selBegin().pos() < cur.selEnd().pos()))
+               cur.selBegin().pos(cur.selBegin().pos() + 1);
+
+       CutAndPaste::copySelection(getPar(cur.selBegin().par()),
+                                  getPar(cur.selEnd().par()),
+                                  cur.selBegin().pos(), 
+                                  cur.selEnd().pos(),
                                   bv()->buffer()->params().textclass);
 }
 
 
 void LyXText::pasteSelection(size_t sel_index)
 {
+       LCursor & cur = bv()->cursor();
        // this does not make sense, if there is nothing to paste
        if (!CutAndPaste::checkPastePossible())
                return;
 
-       recUndo(cursor.par());
+       recUndo(cursor().par());
 
        ParagraphList::iterator endpit;
        PitPosPair ppp;
@@ -1037,7 +990,7 @@ void LyXText::pasteSelection(size_t sel_index)
        boost::tie(ppp, endpit) =
                CutAndPaste::pasteSelection(*bv()->buffer(),
                                            paragraphs(),
-                                           cursorPar(), cursor.pos(),
+                                           cursorPar(), cursor().pos(),
                                            bv()->buffer()->params().textclass,
                                            sel_index, el);
        bufferErrors(*bv()->buffer(), el);
@@ -1045,11 +998,10 @@ void LyXText::pasteSelection(size_t sel_index)
 
        redoParagraphs(cursorPar(), endpit);
 
-       clearSelection();
-
-       selection.cursor = cursor;
+       cur.clearSelection();
+       cur.resetAnchor();
        setCursor(ppp.first, ppp.second);
-       setSelection();
+       cur.setSelection();
        updateCounters();
 }
 
@@ -1059,30 +1011,32 @@ void LyXText::setSelectionRange(lyx::pos_type length)
        if (!length)
                return;
 
-       selection.cursor = cursor;
+       LCursor & cur = bv()->cursor();
+       cur.resetAnchor();
        while (length--)
                cursorRight(true);
-       setSelection();
+       cur.setSelection();
 }
 
 
 // simple replacing. The font of the first selected character is used
 void LyXText::replaceSelectionWithString(string const & str)
 {
-       recUndo(cursor.par());
+       LCursor & cur = bv()->cursor();
+       recUndo(cur.par());
        freezeUndo();
 
        // Get font setting before we cut
-       pos_type pos = selEnd().pos();
-       LyXFont const font = getPar(selStart())
+       pos_type pos = cur.selEnd().pos();
+       LyXFont const font = getPar(cur.selBegin())
                ->getFontSettings(bv()->buffer()->params(),
-                                 selStart().pos());
+                                 cur.selBegin().pos());
 
        // Insert the new string
        string::const_iterator cit = str.begin();
        string::const_iterator end = str.end();
        for (; cit != end; ++cit) {
-               getPar(selEnd())->insertChar(pos, (*cit), font);
+               getPar(cur.selEnd())->insertChar(pos, (*cit), font);
                ++pos;
        }
 
@@ -1096,21 +1050,20 @@ void LyXText::replaceSelectionWithString(string const & str)
 // needed to insert the selection
 void LyXText::insertStringAsLines(string const & str)
 {
+       LCursor & cur = bv()->cursor();
        ParagraphList::iterator pit = cursorPar();
-       pos_type pos = cursor.pos();
+       pos_type pos = cursor().pos();
        ParagraphList::iterator endpit = boost::next(cursorPar());
-
-       recUndo(cursor.par());
+       recordUndo(cur, Undo::ATOMIC);
 
        // only to be sure, should not be neccessary
-       clearSelection();
-
+       cur.clearSelection();
        bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
 
        redoParagraphs(cursorPar(), endpit);
-       selection.cursor = cursor;
+       cur.resetAnchor();
        setCursor(pit, pos);
-       setSelection();
+       cur.setSelection();
 }
 
 
@@ -1151,13 +1104,13 @@ void LyXText::setCursor(ParagraphList::iterator pit, pos_type pos)
 bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont,
        bool boundary)
 {
-       LyXCursor old_cursor = cursor;
+       CursorSlice old_cursor = cursor();
        setCursorIntern(par, pos, setfont, boundary);
        return deleteEmptyParagraphMechanism(old_cursor);
 }
 
 
-void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
+void LyXText::setCursor(CursorSlice & cur, paroffset_type par,
        pos_type pos, bool boundary)
 {
        BOOST_ASSERT(par != int(paragraphs().size()));
@@ -1170,10 +1123,9 @@ void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
        if (paragraphs().begin()->rows.empty())
                return;
 
-       // get the cursor y position in text
-
-       ParagraphList::iterator pit = getPar(par);
-       Row const & row = *pit->getRow(pos);
+       // now some strict checking
+       Paragraph & para = *getPar(par);
+       Row const & row = *para.getRow(pos);
        pos_type const end = row.endpos();
 
        // None of these should happen, but we're scaredy-cats
@@ -1182,9 +1134,9 @@ void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
                pos = 0;
                cur.pos(0);
                BOOST_ASSERT(false);
-       } else if (pos > pit->size()) {
+       } else if (pos > para.size()) {
                lyxerr << "dont like 1, pos: " << pos
-                      << " size: " << pit->size()
+                      << " size: " << para.size()
                       << " row.pos():" << row.pos()
                       << " paroffset: " << par << endl;
                pos = 0;
@@ -1198,7 +1150,7 @@ void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
                BOOST_ASSERT(false);
        } else if (pos < row.pos()) {
                lyxerr << "dont like 3 please report pos:" << pos
-                      << " size: " << pit->size()
+                      << " size: " << para.size()
                       << " row.pos():" << row.pos()
                       << " paroffset: " << par << endl;
                pos = row.pos();
@@ -1211,8 +1163,8 @@ void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
 void LyXText::setCursorIntern(paroffset_type par,
                              pos_type pos, bool setfont, bool boundary)
 {
-       setCursor(cursor, par, pos, boundary);
-       bv()->x_target(cursorX() + xo_);
+       setCursor(cursor(), par, pos, boundary);
+       bv()->cursor().x_target() = cursorX(cursor());
        if (setfont)
                setCurrentFont();
 }
@@ -1220,10 +1172,11 @@ void LyXText::setCursorIntern(paroffset_type par,
 
 void LyXText::setCurrentFont()
 {
-       pos_type pos = cursor.pos();
+       LCursor & cur = bv()->cursor();
+       pos_type pos = cur.pos();
        ParagraphList::iterator pit = cursorPar();
 
-       if (cursor.boundary() && pos > 0)
+       if (cursor().boundary() && pos > 0)
                --pos;
 
        if (pos > 0) {
@@ -1244,9 +1197,9 @@ void LyXText::setCurrentFont()
        current_font = pit->getFontSettings(bufparams, pos);
        real_current_font = getFont(pit, pos);
 
-       if (cursor.pos() == pit->size() &&
-           bidi.isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
-           !cursor.boundary()) {
+       if (cursor().pos() == pit->size() &&
+           bidi.isBoundary(*bv()->buffer(), *pit, cursor().pos()) &&
+           !cursor().boundary()) {
                Language const * lang =
                        pit->getParLanguage(bufparams);
                current_font.setLanguage(lang);
@@ -1262,6 +1215,7 @@ void LyXText::setCurrentFont()
 pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
        Row const & row, int & x, bool & boundary) const
 {
+       x -= xo_;
        double tmpx             = row.x();
        double fill_separator   = row.fill_separator();
        double fill_hfill       = row.fill_hfill();
@@ -1283,7 +1237,7 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
 
        // check for empty row
        if (vc == end) {
-               x = int(tmpx);
+               x = int(tmpx) + xo_;
                return 0;
        }
 
@@ -1327,7 +1281,7 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
 
        // If lastrow is false, we don't need to compute
        // the value of rtl.
-       bool const rtl = (lastrow)
+       bool const rtl = lastrow
                ? pit->isRightToLeftPar(bv()->buffer()->params())
                : false;
        if (lastrow &&
@@ -1355,42 +1309,68 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
                c = end - 1;
        }
 
-       c -= row.pos();
-       x = int(tmpx);
-       return c;
+       x = int(tmpx) + xo_;
+       return c - row.pos();
 }
 
 
 void LyXText::setCursorFromCoordinates(int x, int y)
 {
-       LyXCursor old_cursor = cursor;
-       setCursorFromCoordinates(cursor, x, y);
+       CursorSlice old_cursor = cursor();
+       setCursorFromCoordinates(cursor(), x, y);
        setCurrentFont();
        deleteEmptyParagraphMechanism(old_cursor);
 }
 
 
 // x,y are coordinates relative to this LyXText
-void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
+void LyXText::setCursorFromCoordinates(CursorSlice & cur, int x, int y)
+{
+       ParagraphList::iterator pit;
+       Row const & row = *getRowNearY(y, pit);
+       bool bound = false;
+       pos_type const pos = row.pos() + getColumnNearX(pit, row, x, bound);
+       cur.par() = parOffset(pit);
+       cur.pos() = pos;
+       cur.boundary() = bound;
+}
+
+
+// x,y are absolute screen coordinates
+void LyXText::edit(LCursor & cur, int x, int y)
 {
+       int xx = x; // is modified by getColumnNearX
        ParagraphList::iterator pit;
        Row const & row = *getRowNearY(y, pit);
        bool bound = false;
-       pos_type const column = getColumnNearX(pit, row, x, bound);
-       cur.par(parOffset(pit));
-       cur.pos(row.pos() + column);
-       cur.boundary(bound);
+       pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+       cur.par() = parOffset(pit);
+       cur.pos() = pos;
+       cur.boundary() = bound;
+
+       // try to descend into nested insets
+       InsetBase * inset = checkInsetHit(x, y);
+       if (inset) {
+               // This should be just before or just behind the cursor position
+               // set above.
+               BOOST_ASSERT((pos != 0 && inset == pit->getInset(pos - 1))
+                            || inset == pit->getInset(pos));
+               // Make sure the cursor points to the position before this inset.
+               if (inset == pit->getInset(pos - 1))
+                       --cur.pos();
+               inset->edit(cur, x, y);
+       }
 }
 
 
 bool LyXText::checkAndActivateInset(bool front)
 {
-       if (cursor.pos() == cursorPar()->size())
+       if (cursor().pos() == cursorPar()->size())
                return false;
-       InsetOld * inset = cursorPar()->getInset(cursor.pos());
+       InsetBase * inset = cursorPar()->getInset(cursor().pos());
        if (!isHighlyEditableInset(inset))
                return false;
-       inset->edit(bv(), front);
+       inset->edit(bv()->cursor(), front);
        return true;
 }
 
@@ -1417,13 +1397,13 @@ DispatchResult LyXText::moveRightIntern(bool front, bool activate_inset, bool se
 {
        ParagraphList::iterator c_par = cursorPar();
        if (boost::next(c_par) == paragraphs().end()
-               && cursor.pos() >= c_par->size())
+               && cursor().pos() >= c_par->size())
                return DispatchResult(false, FINISHED_RIGHT);
        if (activate_inset && checkAndActivateInset(front))
                return DispatchResult(true, true);
        cursorRight(true);
        if (!selecting)
-               clearSelection();
+               bv()->cursor().clearSelection();
        return DispatchResult(true);
 }
 
@@ -1431,11 +1411,11 @@ DispatchResult LyXText::moveRightIntern(bool front, bool activate_inset, bool se
 DispatchResult LyXText::moveLeftIntern(bool front,
                          bool activate_inset, bool selecting)
 {
-       if (cursor.par() == 0 && cursor.pos() <= 0)
+       if (cursor().par() == 0 && cursor().pos() <= 0)
                return DispatchResult(false, FINISHED);
        cursorLeft(true);
        if (!selecting)
-               clearSelection();
+               bv()->cursor().clearSelection();
        if (activate_inset && checkAndActivateInset(front))
                return DispatchResult(true, true);
        return DispatchResult(true);
@@ -1444,38 +1424,41 @@ DispatchResult LyXText::moveLeftIntern(bool front,
 
 DispatchResult LyXText::moveUp()
 {
-       if (cursorPar() == firstPar() && cursorRow() == firstRow())
+       LCursor & cur = bv()->cursor();
+       if (cur.par() == 0 && cursorRow() == firstRow())
                return DispatchResult(false, FINISHED_UP);
        cursorUp(false);
-       clearSelection();
+       cur.clearSelection();
        return DispatchResult(true);
 }
 
 
 DispatchResult LyXText::moveDown()
 {
-       if (cursorPar() == lastPar() && cursorRow() == lastRow())
+       LCursor & cur = bv()->cursor();
+       if (cur.par() == cur.lastpar() && cursorRow() == lastRow())
                return DispatchResult(false, FINISHED_DOWN);
        cursorDown(false);
-       clearSelection();
+       cur.clearSelection();
        return DispatchResult(true);
 }
 
 
 bool LyXText::cursorLeft(bool internal)
 {
-       if (cursor.pos() > 0) {
-               bool boundary = cursor.boundary();
-               setCursor(cursor.par(), cursor.pos() - 1, true, false);
+       LCursor & cur = bv()->cursor();
+       if (cur.pos() > 0) {
+               bool boundary = cur.boundary();
+               setCursor(cur.par(), cur.pos() - 1, true, false);
                if (!internal && !boundary &&
-                   bidi.isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
-                       setCursor(cursor.par(), cursor.pos() + 1, true, true);
+                   bidi.isBoundary(*bv()->buffer(), cur.paragraph(), cur.pos() + 1))
+                       setCursor(cur.par(), cur.pos() + 1, true, true);
                return true;
        }
 
-       if (cursor.par() != 0) {
+       if (cur.par() != 0) {
                // steps into the paragraph above
-               setCursor(cursor.par() - 1, boost::prior(cursorPar())->size());
+               setCursor(cur.par() - 1, boost::prior(cursorPar())->size());
                return true;
        }
 
@@ -1485,21 +1468,22 @@ bool LyXText::cursorLeft(bool internal)
 
 bool LyXText::cursorRight(bool internal)
 {
-       if (!internal && cursor.boundary()) {
-               setCursor(cursor.par(), cursor.pos(), true, false);
+       LCursor & cur = bv()->cursor();
+       if (!internal && cur.boundary()) {
+               setCursor(cur.par(), cur.pos(), true, false);
                return true;
        }
 
-       if (cursor.pos() != cursorPar()->size()) {
-               setCursor(cursor.par(), cursor.pos() + 1, true, false);
-               if (!internal && bidi.isBoundary(*bv()->buffer(), *cursorPar(),
-                                                cursor.pos()))
-                       setCursor(cursor.par(), cursor.pos(), true, true);
+       if (cur.pos() != cur.lastpos()) {
+               setCursor(cur.par(), cur.pos() + 1, true, false);
+               if (!internal && bidi.isBoundary(*bv()->buffer(), cur.paragraph(),
+                                                cur.pos()))
+                       setCursor(cur.par(), cur.pos(), true, true);
                return true;
        }
 
-       if (cursor.par() + 1 != int(paragraphs().size())) {
-               setCursor(cursor.par() + 1, 0);
+       if (cur.par() + 1 != int(paragraphs().size())) {
+               setCursor(cur.par() + 1, 0);
                return true;
        }
 
@@ -1509,32 +1493,32 @@ bool LyXText::cursorRight(bool internal)
 
 void LyXText::cursorUp(bool selecting)
 {
+       LCursor & cur = bv()->cursor();
        Row const & row = *cursorRow();
-       int x = bv()->x_target() - xo_;
-       int y = cursorY() - row.baseline() - 1;
+       int x = cur.x_target();
+       int y = cursorY(cur.current()) - row.baseline() - 1;
        setCursorFromCoordinates(x, y);
 
        if (!selecting) {
-               int y_abs = y + yo_ - bv()->top_y();
-               InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+               InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
                if (inset_hit && isHighlyEditableInset(inset_hit))
-                       inset_hit->edit(bv(), bv()->x_target(), y_abs);
+                       inset_hit->edit(cur, cur.x_target(), y);
        }
 }
 
 
 void LyXText::cursorDown(bool selecting)
 {
+       LCursor & cur = bv()->cursor();
        Row const & row = *cursorRow();
-       int x = bv()->x_target() - xo_;
-       int y = cursorY() - row.baseline() + row.height() + 1;
+       int x = cur.x_target();
+       int y = cursorY(cur.current()) - row.baseline() + row.height() + 1;
        setCursorFromCoordinates(x, y);
 
        if (!selecting) {
-               int y_abs = y + yo_ - bv()->top_y();
-               InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+               InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
                if (inset_hit && isHighlyEditableInset(inset_hit))
-                       inset_hit->edit(bv(), bv()->x_target(), y_abs);
+                       inset_hit->edit(cur, cur.x_target(), y);
        }
 }
 
@@ -1542,7 +1526,7 @@ void LyXText::cursorDown(bool selecting)
 void LyXText::cursorUpParagraph()
 {
        ParagraphList::iterator cpit = cursorPar();
-       if (cursor.pos() > 0)
+       if (cursor().pos() > 0)
                setCursor(cpit, 0);
        else if (cpit != paragraphs().begin())
                setCursor(boost::prior(cpit), 0);
@@ -1563,7 +1547,7 @@ void LyXText::cursorDownParagraph()
 
 // fix the cursor `cur' after a characters has been deleted at `where'
 // position. Called by deleteEmptyParagraphMechanism
-void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
+void LyXText::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
 {
        // if cursor is not in the paragraph where the delete occured,
        // do nothing
@@ -1577,21 +1561,25 @@ void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
 
        // check also if we don't want to set the cursor on a spot behind the
        // pagragraph because we erased the last character.
-       if (cur.pos() > getPar(cur)->size())
-               cur.pos(getPar(cur)->size());
+       if (cur.pos() > cur.lastpos())
+               cur.pos() = cur.lastpos();
 }
 
 
-bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
+bool LyXText::deleteEmptyParagraphMechanism(CursorSlice const & old_cursor)
 {
+#warning Disabled as it crashes after the cursor data shift... (Andre)
+       return false;
+
        // Would be wrong to delete anything if we have a selection.
-       if (selection.set())
+       if (bv()->cursor().selection())
                return false;
 
        // Don't do anything if the cursor is invalid
        if (old_cursor.par() == -1)
                return false;
 
+#if 0
        // We allow all kinds of "mumbo-jumbo" when freespacing.
        ParagraphList::iterator const old_pit = getPar(old_cursor);
        if (old_pit->isFreeSpacing())
@@ -1621,8 +1609,8 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
        // MISSING
 
        // If the pos around the old_cursor were spaces, delete one of them.
-       if (old_cursor.par() != cursor.par()
-           || old_cursor.pos() != cursor.pos()) {
+       if (old_cursor.par() != cursor().par()
+           || old_cursor.pos() != cursor().pos()) {
 
                // Only if the cursor has really moved
                if (old_cursor.pos() > 0
@@ -1638,11 +1626,11 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 #warning This will not work anymore when we have multiple views of the same buffer
 // In this case, we will have to correct also the cursors held by
 // other bufferviews. It will probably be easier to do that in a more
-// automated way in LyXCursor code. (JMarc 26/09/2001)
+// automated way in CursorSlice code. (JMarc 26/09/2001)
 #endif
                        // correct all cursors held by the LyXText
-                       fixCursorAfterDelete(cursor, old_cursor);
-                       fixCursorAfterDelete(selection.cursor, old_cursor);
+                       fixCursorAfterDelete(cursor(), old_cursor);
+                       fixCursorAfterDelete(anchor(), old_cursor);
                        return false;
                }
        }
@@ -1656,7 +1644,7 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
                return false;
 
        // only do our magic if we changed paragraph
-       if (old_cursor.par() == cursor.par())
+       if (old_cursor.par() == cursor().par())
                return false;
 
        // record if we have deleted a paragraph
@@ -1666,35 +1654,35 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
        if (old_pit->empty()
            || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
                // ok, we will delete something
-               LyXCursor tmpcursor;
+               CursorSlice tmpcursor;
 
                deleted = true;
 
                bool selection_position_was_oldcursor_position =
-                       selection.cursor.par() == old_cursor.par()
-                       && selection.cursor.pos() == old_cursor.pos();
+                       anchor().par() == old_cursor.par()
+                       && anchor().pos() == old_cursor.pos();
 
-               tmpcursor = cursor;
-               cursor = old_cursor; // that undo can restore the right cursor position
+               tmpcursor = cursor();
+               cursor() = old_cursor; // that undo can restore the right cursor position
 
                ParagraphList::iterator endpit = boost::next(old_pit);
                while (endpit != paragraphs().end() && endpit->getDepth())
                        ++endpit;
 
                recUndo(parOffset(old_pit), parOffset(endpit) - 1);
-               cursor = tmpcursor;
+               cursor() = tmpcursor;
 
                // cache cursor pit
                ParagraphList::iterator tmppit = cursorPar();
                // delete old par
                paragraphs().erase(old_pit);
                // update cursor par offset
-               cursor.par(parOffset(tmppit));
+               cursor().par(parOffset(tmppit));
                redoParagraph();
 
                if (selection_position_was_oldcursor_position) {
                        // correct selection
-                       selection.cursor = cursor;
+                       bv()->resetAnchor();
                }
        }
 
@@ -1703,9 +1691,10 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 
        if (old_pit->stripLeadingSpaces()) {
                redoParagraph(old_pit);
-               selection.cursor = cursor;
+               bv()->resetAnchor();
        }
        return false;
+#endif
 }
 
 
@@ -1717,13 +1706,13 @@ ParagraphList & LyXText::paragraphs() const
 
 void LyXText::recUndo(paroffset_type first, paroffset_type last) const
 {
-       recordUndo(Undo::ATOMIC, this, first, last);
+       recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
 }
 
 
 void LyXText::recUndo(lyx::paroffset_type par) const
 {
-       recordUndo(Undo::ATOMIC, this, par, par);
+       recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
 }
 
 
@@ -1733,6 +1722,26 @@ bool LyXText::isInInset() const
 }
 
 
+bool LyXText::toggleInset()
+{
+       InsetBase * inset = bv()->cursor().nextInset();
+       // is there an editable inset at cursor position?
+       if (!isEditableInset(inset))
+               return false;
+       //bv()->owner()->message(inset->editMessage());
+
+       // do we want to keep this?? (JMarc)
+       if (!isHighlyEditableInset(inset))
+               recUndo(cursor().par());
+
+       if (inset->isOpen())
+               inset->close();
+       else
+               inset->open();
+       return true;
+}
+
+
 int defaultRowHeight()
 {
        return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) *  1.2);