]> git.lyx.org Git - lyx.git/blobdiff - src/text2.C
Fix the missing "Figure #:" label from the caption of a figure float.
[lyx.git] / src / text2.C
index af4e26a4e4db972c68f363554ac7694c1136a872..426cb90be03222c7d00131b5bbe8c411d4429b8f 100644 (file)
@@ -37,6 +37,7 @@
 #include "funcrequest.h"
 #include "gettext.h"
 #include "language.h"
 #include "funcrequest.h"
 #include "gettext.h"
 #include "language.h"
+#include "LColor.h"
 #include "lyxrc.h"
 #include "lyxrow.h"
 #include "lyxrow_funcs.h"
 #include "lyxrc.h"
 #include "lyxrow.h"
 #include "lyxrow_funcs.h"
 #include "support/tostr.h"
 #include "support/std_sstream.h"
 
 #include "support/tostr.h"
 #include "support/std_sstream.h"
 
-#include <boost/tuple/tuple.hpp>
-
+using lyx::par_type;
 using lyx::pos_type;
 using lyx::pos_type;
-using lyx::paroffset_type;
 using lyx::support::bformat;
 
 using std::endl;
 using lyx::support::bformat;
 
 using std::endl;
@@ -70,34 +69,34 @@ using std::ostringstream;
 using std::string;
 
 
 using std::string;
 
 
-LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
-         ParagraphList & paragraphs)
-       : height(0), width(0), inset_owner(inset), bv_owner(bv),
-         in_inset_(ininset), paragraphs_(&paragraphs),
-         cache_pos_(-1), xo_(0), yo_(0)
+LyXText::LyXText(BufferView * bv)
+       : width_(0), maxwidth_(bv ? bv->workWidth() : 100), height_(0),
+         background_color_(LColor::background),
+         bv_owner(bv), xo_(0), yo_(0)
 {}
 
 
 {}
 
 
-void LyXText::init(BufferView * bview)
+void LyXText::init(BufferView * bv)
 {
 {
-       bv_owner = bview;
-
-       ParagraphList::iterator const beg = ownerParagraphs().begin();
-       ParagraphList::iterator const end = ownerParagraphs().end();
-       for (ParagraphList::iterator pit = beg; pit != end; ++pit)
-               pit->rows.clear();
+       BOOST_ASSERT(bv);
+       bv_owner = bv;
+       maxwidth_ = bv->workWidth();
+       width_ = maxwidth_;
+       height_ = 0;
 
 
-       width = 0;
-       height = 0;
-       cache_pos_ = -1;
+       par_type const end = paragraphs().size();
+       for (par_type pit = 0; pit != end; ++pit)
+               pars_[pit].rows.clear();
 
 
-       current_font = getFont(beg, 0);
+       current_font = getFont(0, 0);
+       redoParagraphs(0, end);
+       updateCounters();
+}
 
 
-       redoParagraphs(beg, end);
-       setCursorIntern(0, 0);
-       selection.cursor = cursor;
 
 
-       updateCounters();
+bool LyXText::isMainText() const
+{
+       return &bv()->buffer()->text() == this;
 }
 
 
 }
 
 
@@ -106,20 +105,22 @@ void LyXText::init(BufferView * bview)
 // The difference is that this one is used for displaying, and thus we
 // are allowed to make cosmetic improvements. For instance make footnotes
 // smaller. (Asger)
 // The difference is that this one is used for displaying, and thus we
 // are allowed to make cosmetic improvements. For instance make footnotes
 // smaller. (Asger)
-LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
+LyXFont LyXText::getFont(par_type pit, pos_type pos) const
 {
        BOOST_ASSERT(pos >= 0);
 
 {
        BOOST_ASSERT(pos >= 0);
 
-       LyXLayout_ptr const & layout = pit->layout();
+       LyXLayout_ptr const & layout = pars_[pit].layout();
+#ifdef WITH_WARNINGS
 #warning broken?
 #warning broken?
+#endif
        BufferParams const & params = bv()->buffer()->params();
        BufferParams const & params = bv()->buffer()->params();
-       pos_type const body_pos = pit->beginOfBody();
+       pos_type const body_pos = pars_[pit].beginOfBody();
 
        // We specialize the 95% common case:
 
        // We specialize the 95% common case:
-       if (!pit->getDepth()) {
-               LyXFont f = pit->getFontSettings(params, pos);
-               if (pit->inInset())
-                       pit->inInset()->getDrawFont(f);
+       if (!pars_[pit].getDepth()) {
+               LyXFont f = pars_[pit].getFontSettings(params, pos);
+               if (!isMainText())
+                       f.realize(font_);
                if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
                        return f.realize(layout->reslabelfont);
                else
                if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
                        return f.realize(layout->reslabelfont);
                else
@@ -133,96 +134,74 @@ LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
        else
                layoutfont = layout->font;
 
        else
                layoutfont = layout->font;
 
-       LyXFont font = pit->getFontSettings(params, pos);
+       LyXFont font = pars_[pit].getFontSettings(params, pos);
        font.realize(layoutfont);
 
        font.realize(layoutfont);
 
-       if (pit->inInset())
-               pit->inInset()->getDrawFont(font);
+       if (!isMainText())
+               font.realize(font_);
 
        // Realize with the fonts of lesser depth.
 
        // Realize with the fonts of lesser depth.
-       //font.realize(outerFont(pit, ownerParagraphs()));
+       //font.realize(outerFont(pit, paragraphs()));
        font.realize(defaultfont_);
 
        return font;
 }
 
 
        font.realize(defaultfont_);
 
        return font;
 }
 
 
-LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(par_type pit) const
 {
 {
-       LyXLayout_ptr const & layout = pit->layout();
+       LyXLayout_ptr const & layout = pars_[pit].layout();
 
 
-       if (!pit->getDepth())
+       if (!pars_[pit].getDepth())
                return layout->resfont;
 
        LyXFont font = layout->font;
        // Realize with the fonts of lesser depth.
                return layout->resfont;
 
        LyXFont font = layout->font;
        // Realize with the fonts of lesser depth.
-       //font.realize(outerFont(pit, ownerParagraphs()));
+       //font.realize(outerFont(pit, paragraphs()));
        font.realize(defaultfont_);
 
        return font;
 }
 
 
        font.realize(defaultfont_);
 
        return font;
 }
 
 
-LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(par_type pit) const
 {
 {
-       LyXLayout_ptr const & layout = pit->layout();
+       LyXLayout_ptr const & layout = pars_[pit].layout();
 
 
-       if (!pit->getDepth())
+       if (!pars_[pit].getDepth())
                return layout->reslabelfont;
 
        LyXFont font = layout->labelfont;
        // Realize with the fonts of lesser depth.
                return layout->reslabelfont;
 
        LyXFont font = layout->labelfont;
        // Realize with the fonts of lesser depth.
-       font.realize(outerFont(pit, ownerParagraphs()));
+       font.realize(outerFont(pit, paragraphs()));
        font.realize(defaultfont_);
 
        return font;
 }
 
 
        font.realize(defaultfont_);
 
        return font;
 }
 
 
-void LyXText::setCharFont(ParagraphList::iterator pit,
-                         pos_type pos, LyXFont const & fnt,
-                         bool toggleall)
-{
-       BufferParams const & params = bv()->buffer()->params();
-       LyXFont font = getFont(pit, pos);
-       font.update(fnt, params.language, toggleall);
-       // Let the insets convert their font
-       if (pit->isInset(pos)) {
-               InsetOld * inset = pit->getInset(pos);
-               if (isEditableInset(inset)) {
-                       static_cast<UpdatableInset *>(inset)
-                               ->setFont(bv(), fnt, toggleall, true);
-               }
-       }
-
-       // Plug through to version below:
-       setCharFont(pit, pos, font);
-}
-
-
-void LyXText::setCharFont(
-       ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(par_type pit, pos_type pos, LyXFont const & fnt)
 {
        LyXFont font = fnt;
 {
        LyXFont font = fnt;
-       LyXLayout_ptr const & layout = pit->layout();
+       LyXLayout_ptr const & layout = pars_[pit].layout();
 
        // Get concrete layout font to reduce against
        LyXFont layoutfont;
 
 
        // Get concrete layout font to reduce against
        LyXFont layoutfont;
 
-       if (pos < pit->beginOfBody())
+       if (pos < pars_[pit].beginOfBody())
                layoutfont = layout->labelfont;
        else
                layoutfont = layout->font;
 
        // Realize against environment font information
                layoutfont = layout->labelfont;
        else
                layoutfont = layout->font;
 
        // Realize against environment font information
-       if (pit->getDepth()) {
-               ParagraphList::iterator tp = pit;
+       if (pars_[pit].getDepth()) {
+               par_type tp = pit;
                while (!layoutfont.resolved() &&
                while (!layoutfont.resolved() &&
-                      tp != ownerParagraphs().end() &&
-                      tp->getDepth()) {
-                       tp = outerHook(tp, ownerParagraphs());
-                       if (tp != ownerParagraphs().end())
-                               layoutfont.realize(tp->layout()->font);
+                      tp != par_type(paragraphs().size()) &&
+                      pars_[tp].getDepth()) {
+                       tp = outerHook(tp, paragraphs());
+                       if (tp != par_type(paragraphs().size()))
+                               layoutfont.realize(pars_[tp].layout()->font);
                }
        }
 
                }
        }
 
@@ -231,53 +210,11 @@ void LyXText::setCharFont(
        // Now, reduce font against full layout font
        font.reduce(layoutfont);
 
        // Now, reduce font against full layout font
        font.reduce(layoutfont);
 
-       pit->setFont(pos, font);
-}
-
-
-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;
-}
-
-
-void LyXText::toggleInset()
-{
-       InsetOld * inset = getInset();
-       // is there an editable inset at cursor position?
-       if (!isEditableInset(inset)) {
-               // No, try to see if we are inside a collapsable inset
-               if (inset_owner && inset_owner->owner()
-                   && inset_owner->owner()->isOpen()) {
-                       finishUndo();
-                       inset_owner->owner()->close(bv());
-                       bv()->getLyXText()->cursorRight(true);
-                       bv()->updateParagraphDialog();
-               }
-               return;
-       }
-       //bv()->owner()->message(inset->editMessage());
-
-       // do we want to keep this?? (JMarc)
-       if (!isHighlyEditableInset(inset))
-               recUndo(cursor.par());
-
-       if (inset->isOpen())
-               inset->close(bv());
-       else
-               inset->open(bv());
-
-       bv()->update();
+       pars_[pit].setFont(pos, font);
 }
 
 
 }
 
 
-// used in setLayout 
+// used in setLayout
 // Asger is not sure we want to do this...
 void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
                                            Paragraph & par)
 // Asger is not sure we want to do this...
 void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
                                            Paragraph & par)
@@ -299,196 +236,168 @@ void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
 }
 
 
 }
 
 
-ParagraphList::iterator
-LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
-                  LyXCursor & send_cur,
-                  string const & layout)
+// return past-the-last paragraph influenced by a layout change on pit
+par_type LyXText::undoSpan(par_type pit)
 {
 {
-       ParagraphList::iterator endpit = boost::next(getPar(send_cur));
-       ParagraphList::iterator undoendpit = endpit;
-       ParagraphList::iterator pars_end = ownerParagraphs().end();
-
-       if (endpit != pars_end && endpit->getDepth()) {
-               while (endpit != pars_end && endpit->getDepth()) {
-                       ++endpit;
-                       undoendpit = endpit;
-               }
-       } else if (endpit != pars_end) {
-               // because of parindents etc.
-               ++endpit;
+       par_type end = paragraphs().size();
+       par_type nextpit = pit + 1;
+       if (nextpit == end)
+               return nextpit;
+       //because of parindents
+       if (!pars_[pit].getDepth())
+               return boost::next(nextpit);
+       //because of depth constrains
+       for (; nextpit != end; ++pit, ++nextpit) {
+               if (!pars_[pit].getDepth())
+                       break;
        }
        }
+       return nextpit;
+}
 
 
-       recUndo(sstart_cur.par(), parOffset(undoendpit) - 1);
 
 
-       // ok we have a selection. This is always between sstart_cur
-       // and sel_end cursor
-       cur = sstart_cur;
-       ParagraphList::iterator pit = getPar(sstart_cur);
-       ParagraphList::iterator epit = boost::next(getPar(send_cur));
+par_type LyXText::setLayout(par_type start, par_type end, string const & layout)
+{
+       BOOST_ASSERT(start != end);
+       par_type undopit = undoSpan(end - 1);
+       recUndo(start, undopit - 1);
 
        BufferParams const & bufparams = bv()->buffer()->params();
 
        BufferParams const & bufparams = bv()->buffer()->params();
-       LyXLayout_ptr const & lyxlayout =
-               bufparams.getLyXTextClass()[layout];
-
-       do {
-               pit->applyLayout(lyxlayout);
-               makeFontEntriesLayoutSpecific(bufparams, *pit);
-               pit->params().spaceTop(lyxlayout->fill_top ?
-                                        VSpace(VSpace::VFILL)
-                                        : VSpace(VSpace::NONE));
-               pit->params().spaceBottom(lyxlayout->fill_bottom ?
-                                           VSpace(VSpace::VFILL)
-                                           : VSpace(VSpace::NONE));
+       LyXLayout_ptr const & lyxlayout = bufparams.getLyXTextClass()[layout];
+
+       for (par_type pit = start; pit != end; ++pit) {
+               pars_[pit].applyLayout(lyxlayout);
+               makeFontEntriesLayoutSpecific(bufparams, pars_[pit]);
                if (lyxlayout->margintype == MARGIN_MANUAL)
                if (lyxlayout->margintype == MARGIN_MANUAL)
-                       pit->setLabelWidthString(lyxlayout->labelstring());
-               cur.par(std::distance(ownerParagraphs().begin(), pit));
-               ++pit;
-       } while (pit != epit);
+                       pars_[pit].setLabelWidthString(lyxlayout->labelstring());
+       }
 
 
-       return endpit;
+       return undopit;
 }
 
 
 // set layout over selection and make a total rebreak of those paragraphs
 }
 
 
 // set layout over selection and make a total rebreak of those paragraphs
-void LyXText::setLayout(string const & layout)
+void LyXText::setLayout(LCursor & cur, string const & layout)
 {
 {
-       LyXCursor tmpcursor = cursor;  // store the current cursor
-
-       // if there is no selection just set the layout
-       // of the current paragraph
-       if (!selection.set()) {
-               selection.start = cursor;  // dummy selection
-               selection.end = cursor;
-       }
-
+       BOOST_ASSERT(this == cur.text());
        // special handling of new environment insets
        // special handling of new environment insets
-       BufferParams const & params = bv()->buffer()->params();
+       BufferView & bv = cur.bv();
+       BufferParams const & params = bv.buffer()->params();
        LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
        if (lyxlayout->is_environment) {
                // move everything in a new environment inset
                lyxerr << "setting layout " << layout << endl;
        LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
        if (lyxlayout->is_environment) {
                // move everything in a new environment inset
                lyxerr << "setting layout " << layout << endl;
-               bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
-               bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
-               bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
-               InsetOld * inset = new InsetEnvironment(params, layout);
-               if (bv()->insertInset(inset)) {
-                       //inset->edit(bv());
-                       //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
-               }
-               else
-                       delete inset;
+               bv.owner()->dispatch(FuncRequest(LFUN_HOME));
+               bv.owner()->dispatch(FuncRequest(LFUN_ENDSEL));
+               bv.owner()->dispatch(FuncRequest(LFUN_CUT));
+               InsetBase * inset = new InsetEnvironment(params, layout);
+               insertInset(cur, inset);
+               //inset->edit(cur, true);
+               //bv.owner()->dispatch(FuncRequest(LFUN_PASTE));
                return;
        }
 
                return;
        }
 
-       ParagraphList::iterator endpit = setLayout(cursor, selection.start,
-                                                  selection.end, layout);
-       redoParagraphs(getPar(selection.start), endpit);
-
-       // we have to reset the selection, because the
-       // geometry could have changed
-       setCursor(selection.start.par(), selection.start.pos(), false);
-       selection.cursor = cursor;
-       setCursor(selection.end.par(), selection.end.pos(), false);
+       par_type start = cur.selBegin().par();
+       par_type end = cur.selEnd().par() + 1;
+       par_type endpit = setLayout(start, end, layout);
+       redoParagraphs(start, endpit);
        updateCounters();
        updateCounters();
-       clearSelection();
-       setSelection();
-       setCursor(tmpcursor.par(), tmpcursor.pos(), true);
 }
 
 
 }
 
 
-bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
+namespace {
+
+
+void getSelectionSpan(LCursor & cur, par_type & beg, par_type & end)
 {
 {
-       ParagraphList::iterator pit = cursorPar();
-       ParagraphList::iterator end = pit;
-       ParagraphList::iterator start = pit;
-
-       if (selection.set()) {
-               pit = getPar(selection.start);
-               end = getPar(selection.end);
-               start = pit;
+       if (!cur.selection()) {
+               beg = cur.par();
+               end = cur.par() + 1;
+       } else {
+               beg = cur.selBegin().par();
+               end = cur.selEnd().par() + 1;
        }
        }
+}
 
 
-       ParagraphList::iterator pastend = boost::next(end);
-
-       if (!test_only)
-               recUndo(parOffset(start), parOffset(end));
 
 
-       bool changed = false;
+bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
+       Paragraph const & par, int max_depth)
+{
+       if (par.layout()->labeltype == LABEL_BIBLIO)
+               return false;
+       int const depth = par.params().depth();
+       if (type == LyXText::INC_DEPTH && depth < max_depth)
+               return true;
+       if (type == LyXText::DEC_DEPTH && depth > 0)
+               return true;
+       return false;
+}
 
 
-       int prev_after_depth = 0;
-#warning parlist ... could be nicer ?
-       if (start != ownerParagraphs().begin()) {
-               prev_after_depth = boost::prior(start)->getMaxDepthAfter();
-       }
 
 
-       while (true) {
-               int const depth = pit->params().depth();
-               if (type == bv_funcs::INC_DEPTH) {
-                       if (depth < prev_after_depth
-                           && pit->layout()->labeltype != LABEL_BIBLIO) {
-                               changed = true;
-                               if (!test_only)
-                                       pit->params().depth(depth + 1);
-                       }
-               } else if (depth) {
-                       changed = true;
-                       if (!test_only)
-                               pit->params().depth(depth - 1);
-               }
+}
 
 
-               prev_after_depth = pit->getMaxDepthAfter();
 
 
-#warning SERIOUS: Uahh... does this mean we access end->getMaxDepthAfter?
-               if (pit == end) {
-                       break;
-               }
+bool LyXText::changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const
+{
+       BOOST_ASSERT(this == cur.text());
+       par_type beg, end;
+       getSelectionSpan(cur, beg, end);
+       int max_depth = 0;
+       if (beg != 0)
+               max_depth = pars_[beg - 1].getMaxDepthAfter();
 
 
-               ++pit;
+       for (par_type pit = beg; pit != end; ++pit) {
+               if (::changeDepthAllowed(type, pars_[pit], max_depth))
+                       return true;
+               max_depth = pars_[pit].getMaxDepthAfter();
        }
        }
+       return false;
+}
 
 
-       if (test_only)
-               return changed;
 
 
-       redoParagraphs(start, pastend);
+void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
+{
+       BOOST_ASSERT(this == cur.text());
+       par_type beg, end;
+       getSelectionSpan(cur, beg, end);
+       recordUndoSelection(cur);
 
 
-       // We need to actually move the text->cursor. I don't
-       // understand why ...
-       LyXCursor tmpcursor = cursor;
+       int max_depth = 0;
+       if (beg != 0)
+               max_depth = pars_[beg - 1].getMaxDepthAfter();
 
 
-       // we have to reset the visual selection because the
-       // geometry could have changed
-       if (selection.set()) {
-               setCursor(selection.start.par(), selection.start.pos());
-               selection.cursor = cursor;
-               setCursor(selection.end.par(), selection.end.pos());
+       for (par_type pit = beg; pit != end; ++pit) {
+               if (::changeDepthAllowed(type, pars_[pit], max_depth)) {
+                       int const depth = pars_[pit].params().depth();
+                       if (type == INC_DEPTH)
+                               pars_[pit].params().depth(depth + 1);
+                       else
+                               pars_[pit].params().depth(depth - 1);
+               }
+               max_depth = pars_[pit].getMaxDepthAfter();
        }
        }
-
        // this handles the counter labels, and also fixes up
        // depth values for follow-on (child) paragraphs
        updateCounters();
        // this handles the counter labels, and also fixes up
        // depth values for follow-on (child) paragraphs
        updateCounters();
-
-       setSelection();
-       setCursor(tmpcursor.par(), tmpcursor.pos());
-
-       return changed;
 }
 
 
 }
 
 
-// set font over selection and make a total rebreak of those paragraphs
-void LyXText::setFont(LyXFont const & font, bool toggleall)
+// set font over selection
+void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
 {
 {
+       BOOST_ASSERT(this == cur.text());
        // if there is no selection just set the current_font
        // if there is no selection just set the current_font
-       if (!selection.set()) {
+       if (!cur.selection()) {
                // Determine basis font
                LyXFont layoutfont;
                // Determine basis font
                LyXFont layoutfont;
-               if (cursor.pos() < cursorPar()->beginOfBody()) {
-                       layoutfont = getLabelFont(cursorPar());
-               } else {
-                       layoutfont = getLayoutFont(cursorPar());
-               }
+               par_type pit = cur.par();
+               if (cur.pos() < pars_[pit].beginOfBody())
+                       layoutfont = getLabelFont(pit);
+               else
+                       layoutfont = getLayoutFont(pit);
+
                // Update current font
                real_current_font.update(font,
                // Update current font
                real_current_font.update(font,
-                                        bv()->buffer()->params().language,
+                                        cur.buffer().params().language,
                                         toggleall);
 
                // Reduce to implicit settings
                                         toggleall);
 
                // Reduce to implicit settings
@@ -500,208 +409,147 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
                return;
        }
 
                return;
        }
 
-       LyXCursor tmpcursor = cursor; // store the current cursor
-
-       // ok we have a selection. This is always between sel_start_cursor
-       // and sel_end cursor
-
-       recUndo(selection.start.par(), selection.end.par());
-       freezeUndo();
-       cursor = selection.start;
-       while (cursor.par() != selection.end.par() ||
-              cursor.pos() < selection.end.pos())
-       {
-               if (cursor.pos() < cursorPar()->size()) {
-                       // an open footnote should behave like a closed one
-                       setCharFont(cursorPar(), cursor.pos(), font, toggleall);
-                       cursor.pos(cursor.pos() + 1);
-               } else {
-                       cursor.pos(0);
-                       cursor.par(cursor.par() + 1);
-               }
-       }
-       unFreezeUndo();
-
-       redoParagraph(getPar(selection.start));
-
-       // we have to reset the selection, because the
-       // geometry could have changed, but we keep
-       // it for user convenience
-       setCursor(selection.start.par(), selection.start.pos());
-       selection.cursor = cursor;
-       setCursor(selection.end.par(), selection.end.pos());
-       setSelection();
-       setCursor(tmpcursor.par(), tmpcursor.pos(), true,
-                 tmpcursor.boundary());
-}
-
-
-// important for the screen
+       // Ok, we have a selection.
+       recordUndoSelection(cur);
 
 
+       par_type const beg = cur.selBegin().par();
+       par_type const end = cur.selEnd().par();
 
 
-// the cursor set functions have a special mechanism. When they
-// realize, that you left an empty paragraph, they will delete it.
+       DocIterator pos = cur.selectionBegin();
+       DocIterator posend = cur.selectionEnd();
 
 
-// need the selection cursor:
-void LyXText::setSelection()
-{
-       TextCursor::setSelection();
-}
+       lyxerr << "pos: " << pos << " posend: " << posend << endl;
 
 
+       BufferParams const & params = cur.buffer().params();
 
 
-void LyXText::clearSelection()
-{
-       TextCursor::clearSelection();
+       // Don't use forwardChar here as posend might have
+       // pos() == lastpos() and forwardChar would miss it.
+       for (; pos != posend; pos.forwardPos()) {
+               if (pos.pos() != pos.lastpos()) {
+                       LyXFont f = getFont(pos.par(), pos.pos());
+                       f.update(font, params.language, toggleall);
+                       setCharFont(pos.par(), pos.pos(), f);
+               }
+       }
 
 
-       // reset this in the bv()!
-       if (bv() && bv()->text)
-               bv()->text->xsel_cache.set(false);
+       redoParagraphs(beg, end + 1);
 }
 
 
 }
 
 
-void LyXText::cursorHome()
+// the cursor set functions have a special mechanism. When they
+// realize you left an empty paragraph, they will delete it.
+
+void LyXText::cursorHome(LCursor & cur)
 {
 {
-       ParagraphList::iterator cpit = cursorPar();
-       setCursor(cpit, cpit->getRow(cursor.pos())->pos());
+       BOOST_ASSERT(this == cur.text());
+       setCursor(cur, cur.par(), cur.textRow().pos());
 }
 
 
 }
 
 
-void LyXText::cursorEnd()
+void LyXText::cursorEnd(LCursor & cur)
 {
 {
-       ParagraphList::iterator cpit = cursorPar();
-       pos_type end = cpit->getRow(cursor.pos())->endpos();
+       BOOST_ASSERT(this == cur.text());
        // if not on the last row of the par, put the cursor before
        // the final space
        // if not on the last row of the par, put the cursor before
        // the final space
-       setCursor(cpit, end == cpit->size() ? end : end - 1);
+       pos_type const end = cur.textRow().endpos();
+       setCursor(cur, cur.par(), end == cur.lastpos() ? end : end - 1);
 }
 
 
 }
 
 
-void LyXText::cursorTop()
+void LyXText::cursorTop(LCursor & cur)
 {
 {
-       setCursor(ownerParagraphs().begin(), 0);
+       BOOST_ASSERT(this == cur.text());
+       setCursor(cur, 0, 0);
 }
 
 
 }
 
 
-void LyXText::cursorBottom()
+void LyXText::cursorBottom(LCursor & cur)
 {
 {
-       ParagraphList::iterator lastpit =
-               boost::prior(ownerParagraphs().end());
-       setCursor(lastpit, lastpit->size());
+       BOOST_ASSERT(this == cur.text());
+       setCursor(cur, cur.lastpar(), boost::prior(paragraphs().end())->size());
 }
 
 
 }
 
 
-void LyXText::toggleFree(LyXFont const & font, bool toggleall)
+void LyXText::toggleFree(LCursor & cur, LyXFont const & font, bool toggleall)
 {
 {
+       BOOST_ASSERT(this == cur.text());
        // If the mask is completely neutral, tell user
        if (font == LyXFont(LyXFont::ALL_IGNORE)) {
                // Could only happen with user style
        // If the mask is completely neutral, tell user
        if (font == LyXFont(LyXFont::ALL_IGNORE)) {
                // Could only happen with user style
-               bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
+               cur.message(_("No font change defined. "
+                       "Use Character under the Layout menu to define font change."));
                return;
        }
 
        // Try implicit word selection
        // If there is a change in the language the implicit word selection
        // is disabled.
                return;
        }
 
        // Try implicit word selection
        // If there is a change in the language the implicit word selection
        // is disabled.
-       LyXCursor resetCursor = cursor;
+       CursorSlice resetCursor = cur.top();
        bool implicitSelection =
                font.language() == ignore_language
                && font.number() == LyXFont::IGNORE
        bool implicitSelection =
                font.language() == ignore_language
                && font.number() == LyXFont::IGNORE
-               && selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT);
+               && selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD_STRICT);
 
        // Set font
 
        // Set font
-       setFont(font, toggleall);
+       setFont(cur, font, toggleall);
 
        // Implicit selections are cleared afterwards
 
        // Implicit selections are cleared afterwards
-       //and cursor is set to the original position.
+       // and cursor is set to the original position.
        if (implicitSelection) {
        if (implicitSelection) {
-               clearSelection();
-               cursor = resetCursor;
-               setCursor(cursorPar(), cursor.pos());
-               selection.cursor = cursor;
+               cur.clearSelection();
+               cur.top() = resetCursor;
+               cur.resetAnchor();
        }
 }
 
 
        }
 }
 
 
-string LyXText::getStringToIndex()
+string LyXText::getStringToIndex(LCursor & cur)
 {
 {
+       BOOST_ASSERT(this == cur.text());
        // Try implicit word selection
        // If there is a change in the language the implicit word selection
        // is disabled.
        // 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 = cur.top();
        bool const implicitSelection =
        bool const implicitSelection =
-               selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
+               selectWordWhenUnderCursor(cur, lyx::PREVIOUS_WORD);
 
        string idxstring;
 
        string idxstring;
-       if (!selection.set())
-               bv()->owner()->message(_("Nothing to index!"));
-       else if (selection.start.par() != selection.end.par())
-               bv()->owner()->message(_("Cannot index more than one paragraph!"));
+       if (!cur.selection())
+               cur.message(_("Nothing to index!"));
+       else if (cur.selBegin().par() != cur.selEnd().par())
+               cur.message(_("Cannot index more than one paragraph!"));
        else
        else
-               idxstring = selectionAsString(*bv()->buffer(), false);
+               idxstring = cur.selectionAsString(false);
 
        // Reset cursors to their original position.
 
        // Reset cursors to their original position.
-       cursor = reset_cursor;
-       setCursor(cursorPar(), cursor.pos());
-       selection.cursor = cursor;
+       cur.top() = reset_cursor;
+       cur.resetAnchor();
 
        // Clear the implicit selection.
        if (implicitSelection)
 
        // Clear the implicit selection.
        if (implicitSelection)
-               clearSelection();
+               cur.clearSelection();
 
        return idxstring;
 }
 
 
 
        return idxstring;
 }
 
 
-// the DTP switches for paragraphs. LyX will store them in the first
-// physical paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make sure,
-// they do not duplicate themself and you cannot play dirty tricks with
-// them!
-
-void LyXText::setParagraph(
-                          VSpace const & space_top,
-                          VSpace const & space_bottom,
-                          Spacing const & spacing,
-                          LyXAlignment align,
-                          string const & labelwidthstring,
-                          bool noindent)
+void LyXText::setParagraph(LCursor & cur,
+       Spacing const & spacing, LyXAlignment align,
+       string const & labelwidthstring, bool noindent)
 {
 {
-       LyXCursor tmpcursor = cursor;
-       if (!selection.set()) {
-               selection.start = cursor;
-               selection.end = cursor;
-       }
-
+       BOOST_ASSERT(cur.text());
        // make sure that the depth behind the selection are restored, too
        // make sure that the depth behind the selection are restored, too
-       ParagraphList::iterator endpit = boost::next(getPar(selection.end));
-       ParagraphList::iterator undoendpit = endpit;
-       ParagraphList::iterator pars_end = ownerParagraphs().end();
-
-       if (endpit != pars_end && endpit->getDepth()) {
-               while (endpit != pars_end && endpit->getDepth()) {
-                       ++endpit;
-                       undoendpit = endpit;
-               }
-       } else if (endpit != pars_end) {
-               // because of parindents etc.
-               ++endpit;
-       }
+       par_type undopit = undoSpan(cur.selEnd().par());
+       recUndo(cur.selBegin().par(), undopit - 1);
 
 
-       recUndo(selection.start.par(), parOffset(undoendpit) - 1);
-
-       int tmppit = selection.end.par();
-
-       while (tmppit != selection.start.par() - 1) {
-               setCursor(tmppit, 0);
-
-               ParagraphList::iterator const pit = cursorPar();
-               ParagraphParameters & params = pit->params();
-               params.spaceTop(space_top);
-               params.spaceBottom(space_bottom);
+       for (par_type pit = cur.selBegin().par(), end = cur.selEnd().par();
+                       pit <= end; ++pit) {
+               Paragraph & par = pars_[pit];
+               ParagraphParameters & params = par.params();
                params.spacing(spacing);
 
                // does the layout allow the new alignment?
                params.spacing(spacing);
 
                // does the layout allow the new alignment?
-               LyXLayout_ptr const & layout = pit->layout();
+               LyXLayout_ptr const & layout = par.layout();
 
                if (align == LYX_ALIGN_LAYOUT)
                        align = layout->align;
 
                if (align == LYX_ALIGN_LAYOUT)
                        align = layout->align;
@@ -711,25 +559,14 @@ void LyXText::setParagraph(
                        else
                                params.align(align);
                }
                        else
                                params.align(align);
                }
-               pit->setLabelWidthString(labelwidthstring);
+               par.setLabelWidthString(labelwidthstring);
                params.noindent(noindent);
                params.noindent(noindent);
-               --tmppit;
        }
 
        }
 
-       redoParagraphs(getPar(selection.start), endpit);
-
-       clearSelection();
-       setCursor(selection.start.par(), selection.start.pos());
-       selection.cursor = cursor;
-       setCursor(selection.end.par(), selection.end.pos());
-       setSelection();
-       setCursor(tmpcursor.par(), tmpcursor.pos());
-       bv()->update();
+       redoParagraphs(cur.selBegin().par(), undopit);
 }
 
 
 }
 
 
-namespace {
-
 string expandLabel(LyXTextClass const & textclass,
        LyXLayout_ptr const & layout, bool appendix)
 {
 string expandLabel(LyXTextClass const & textclass,
        LyXLayout_ptr const & layout, bool appendix)
 {
@@ -752,34 +589,34 @@ string expandLabel(LyXTextClass const & textclass,
 }
 
 
 }
 
 
-void incrementItemDepth(ParagraphList::iterator pit,
-                       ParagraphList::iterator first_pit)
+namespace {
+
+void incrementItemDepth(ParagraphList & pars, par_type pit, par_type first_pit)
 {
 {
-       int const cur_labeltype = pit->layout()->labeltype;
+       int const cur_labeltype = pars[pit].layout()->labeltype;
 
 
-       if (cur_labeltype != LABEL_ENUMERATE &&
-           cur_labeltype != LABEL_ITEMIZE)
+       if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
                return;
 
                return;
 
-       int const cur_depth = pit->getDepth();
+       int const cur_depth = pars[pit].getDepth();
 
 
-       ParagraphList::iterator prev_pit = boost::prior(pit);
+       par_type prev_pit = pit - 1;
        while (true) {
        while (true) {
-               int const prev_depth = prev_pit->getDepth();
-               int const prev_labeltype = prev_pit->layout()->labeltype;
+               int const prev_depth = pars[prev_pit].getDepth();
+               int const prev_labeltype = pars[prev_pit].layout()->labeltype;
                if (prev_depth == 0 && cur_depth > 0) {
                        if (prev_labeltype == cur_labeltype) {
                if (prev_depth == 0 && cur_depth > 0) {
                        if (prev_labeltype == cur_labeltype) {
-                               pit->itemdepth = prev_pit->itemdepth + 1;
+                               pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
                        }
                        break;
                } else if (prev_depth < cur_depth) {
                        if (prev_labeltype == cur_labeltype) {
                        }
                        break;
                } else if (prev_depth < cur_depth) {
                        if (prev_labeltype == cur_labeltype) {
-                               pit->itemdepth = prev_pit->itemdepth + 1;
+                               pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
                                break;
                        }
                } else if (prev_depth == cur_depth) {
                        if (prev_labeltype == cur_labeltype) {
                                break;
                        }
                } else if (prev_depth == cur_depth) {
                        if (prev_labeltype == cur_labeltype) {
-                               pit->itemdepth = prev_pit->itemdepth;
+                               pars[pit].itemdepth = pars[prev_pit].itemdepth;
                                break;
                        }
                }
                                break;
                        }
                }
@@ -791,21 +628,20 @@ void incrementItemDepth(ParagraphList::iterator pit,
 }
 
 
 }
 
 
-void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
-                             ParagraphList::iterator firstpit,
-                             Counters & counters)
+void resetEnumCounterIfNeeded(ParagraphList & pars, par_type pit,
+       par_type firstpit, Counters & counters)
 {
        if (pit == firstpit)
                return;
 
 {
        if (pit == firstpit)
                return;
 
-       int const cur_depth = pit->getDepth();
-       ParagraphList::iterator prev_pit = boost::prior(pit);
+       int const cur_depth = pars[pit].getDepth();
+       par_type prev_pit = pit - 1;
        while (true) {
        while (true) {
-               int const prev_depth = prev_pit->getDepth();
-               int const prev_labeltype = prev_pit->layout()->labeltype;
+               int const prev_depth = pars[prev_pit].getDepth();
+               int const prev_labeltype = pars[prev_pit].layout()->labeltype;
                if (prev_depth <= cur_depth) {
                        if (prev_labeltype != LABEL_ENUMERATE) {
                if (prev_depth <= cur_depth) {
                        if (prev_labeltype != LABEL_ENUMERATE) {
-                               switch (pit->itemdepth) {
+                               switch (pars[pit].itemdepth) {
                                case 0:
                                        counters.reset("enumi");
                                case 1:
                                case 0:
                                        counters.reset("enumi");
                                case 1:
@@ -830,39 +666,39 @@ void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
 
 
 // set the counter of a paragraph. This includes the labels
 
 
 // set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
+void LyXText::setCounter(Buffer const & buf, par_type pit)
 {
        BufferParams const & bufparams = buf.params();
        LyXTextClass const & textclass = bufparams.getLyXTextClass();
 {
        BufferParams const & bufparams = buf.params();
        LyXTextClass const & textclass = bufparams.getLyXTextClass();
-       LyXLayout_ptr const & layout = pit->layout();
-       ParagraphList::iterator first_pit = ownerParagraphs().begin();
+       LyXLayout_ptr const & layout = pars_[pit].layout();
+       par_type first_pit = 0;
        Counters & counters = textclass.counters();
 
        // Always reset
        Counters & counters = textclass.counters();
 
        // Always reset
-       pit->itemdepth = 0;
+       pars_[pit].itemdepth = 0;
 
        if (pit == first_pit) {
 
        if (pit == first_pit) {
-               pit->params().appendix(pit->params().startOfAppendix());
+               pars_[pit].params().appendix(pars_[pit].params().startOfAppendix());
        } else {
        } else {
-               pit->params().appendix(boost::prior(pit)->params().appendix());
-               if (!pit->params().appendix() &&
-                   pit->params().startOfAppendix()) {
-                       pit->params().appendix(true);
+               pars_[pit].params().appendix(pars_[pit - 1].params().appendix());
+               if (!pars_[pit].params().appendix() &&
+                   pars_[pit].params().startOfAppendix()) {
+                       pars_[pit].params().appendix(true);
                        textclass.counters().reset();
                }
 
                // Maybe we have to increment the item depth.
                        textclass.counters().reset();
                }
 
                // Maybe we have to increment the item depth.
-               incrementItemDepth(pit, first_pit);
+               incrementItemDepth(pars_, pit, first_pit);
        }
 
        // erase what was there before
        }
 
        // erase what was there before
-       pit->params().labelString(string());
+       pars_[pit].params().labelString(string());
 
        if (layout->margintype == MARGIN_MANUAL) {
 
        if (layout->margintype == MARGIN_MANUAL) {
-               if (pit->params().labelWidthString().empty())
-                       pit->setLabelWidthString(layout->labelstring());
+               if (pars_[pit].params().labelWidthString().empty())
+                       pars_[pit].setLabelWidthString(layout->labelstring());
        } else {
        } else {
-               pit->setLabelWidthString(string());
+               pars_[pit].setLabelWidthString(string());
        }
 
        // is it a layout that has an automatic label?
        }
 
        // is it a layout that has an automatic label?
@@ -870,16 +706,16 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
                BufferParams const & bufparams = buf.params();
                LyXTextClass const & textclass = bufparams.getLyXTextClass();
                counters.step(layout->counter);
                BufferParams const & bufparams = buf.params();
                LyXTextClass const & textclass = bufparams.getLyXTextClass();
                counters.step(layout->counter);
-               string label = expandLabel(textclass, layout, pit->params().appendix());
-               pit->params().labelString(label);
+               string label = expandLabel(textclass, layout, pars_[pit].params().appendix());
+               pars_[pit].params().labelString(label);
        } else if (layout->labeltype == LABEL_ITEMIZE) {
                // At some point of time we should do something more
                // clever here, like:
        } else if (layout->labeltype == LABEL_ITEMIZE) {
                // At some point of time we should do something more
                // clever here, like:
-               //   pit->params().labelString(
-               //    bufparams.user_defined_bullet(pit->itemdepth).getText());
+               //   pars_[pit].params().labelString(
+               //    bufparams.user_defined_bullet(pars_[pit].itemdepth).getText());
                // for now, use a simple hardcoded label
                string itemlabel;
                // for now, use a simple hardcoded label
                string itemlabel;
-               switch (pit->itemdepth) {
+               switch (pars_[pit].itemdepth) {
                case 0:
                        itemlabel = "*";
                        break;
                case 0:
                        itemlabel = "*";
                        break;
@@ -894,17 +730,17 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
                        break;
                }
 
                        break;
                }
 
-               pit->params().labelString(itemlabel);
+               pars_[pit].params().labelString(itemlabel);
        } else if (layout->labeltype == LABEL_ENUMERATE) {
                // Maybe we have to reset the enumeration counter.
        } else if (layout->labeltype == LABEL_ENUMERATE) {
                // Maybe we have to reset the enumeration counter.
-               resetEnumCounterIfNeeded(pit, first_pit, counters);
+               resetEnumCounterIfNeeded(pars_, pit, first_pit, counters);
 
                // FIXME
                // Yes I know this is a really, really! bad solution
                // (Lgb)
                string enumcounter = "enum";
 
 
                // FIXME
                // Yes I know this is a really, really! bad solution
                // (Lgb)
                string enumcounter = "enum";
 
-               switch (pit->itemdepth) {
+               switch (pars_[pit].itemdepth) {
                case 2:
                        enumcounter += 'i';
                case 1:
                case 2:
                        enumcounter += 'i';
                case 1:
@@ -922,13 +758,13 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 
                counters.step(enumcounter);
 
 
                counters.step(enumcounter);
 
-               pit->params().labelString(counters.enumLabel(enumcounter));
+               pars_[pit].params().labelString(counters.enumLabel(enumcounter));
        } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
                counters.step("bibitem");
                int number = counters.value("bibitem");
        } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
                counters.step("bibitem");
                int number = counters.value("bibitem");
-               if (pit->bibitem()) {
-                       pit->bibitem()->setCounter(number);
-                       pit->params().labelString(layout->labelstring());
+               if (pars_[pit].bibitem()) {
+                       pars_[pit].bibitem()->setCounter(number);
+                       pars_[pit].params().labelString(layout->labelstring());
                }
                // In biblio should't be following counters but...
        } else {
                }
                // In biblio should't be following counters but...
        } else {
@@ -936,23 +772,21 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 
                // the caption hack:
                if (layout->labeltype == LABEL_SENSITIVE) {
 
                // the caption hack:
                if (layout->labeltype == LABEL_SENSITIVE) {
-                       ParagraphList::iterator end = ownerParagraphs().end();
-                       ParagraphList::iterator tmppit = pit;
-                       InsetOld * in = 0;
+                       par_type end = paragraphs().size();
+                       par_type tmppit = pit;
+                       InsetBase * in = 0;
                        bool isOK = false;
                        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) {
+                       while (tmppit != end) {
+                               in = pars_[tmppit].inInset();
+                               if (in->lyxCode() == InsetBase::FLOAT_CODE ||
+                                   in->lyxCode() == InsetBase::WRAP_CODE) {
                                        isOK = true;
                                        break;
                                } else {
                                        Paragraph const * owner = &ownerPar(buf, in);
                                        tmppit = first_pit;
                                        for ( ; tmppit != end; ++tmppit)
                                        isOK = true;
                                        break;
                                } else {
                                        Paragraph const * owner = &ownerPar(buf, in);
                                        tmppit = first_pit;
                                        for ( ; tmppit != end; ++tmppit)
-                                               if (&*tmppit == owner)
+                                               if (&pars_[tmppit] == owner)
                                                        break;
                                }
                        }
                                                        break;
                                }
                        }
@@ -960,9 +794,9 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
                        if (isOK) {
                                string type;
 
                        if (isOK) {
                                string type;
 
-                               if (in->lyxCode() == InsetOld::FLOAT_CODE)
+                               if (in->lyxCode() == InsetBase::FLOAT_CODE)
                                        type = static_cast<InsetFloat*>(in)->params().type;
                                        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);
                                        type = static_cast<InsetWrap*>(in)->params().type;
                                else
                                        BOOST_ASSERT(false);
@@ -979,274 +813,85 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
                                s = _("Senseless: ");
                        }
                }
                                s = _("Senseless: ");
                        }
                }
-               pit->params().labelString(s);
+               pars_[pit].params().labelString(s);
 
        }
 }
 
 
 
        }
 }
 
 
-// Updates all counters. Paragraphs with changed label string will be rebroken
+// Updates all counters.
 void LyXText::updateCounters()
 {
        // start over
        bv()->buffer()->params().getLyXTextClass().counters().reset();
 
 void LyXText::updateCounters()
 {
        // start over
        bv()->buffer()->params().getLyXTextClass().counters().reset();
 
-       ParagraphList::iterator beg = ownerParagraphs().begin();
-       ParagraphList::iterator end = ownerParagraphs().end();
-       for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
-               string const oldLabel = pit->params().labelString();
+       bool update_pos = false;
 
 
+       par_type end = paragraphs().size();
+       for (par_type pit = 0; pit != end; ++pit) {
+               string const oldLabel = pars_[pit].params().labelString();
                size_t maxdepth = 0;
                size_t maxdepth = 0;
-               if (pit != beg)
-                       maxdepth = boost::prior(pit)->getMaxDepthAfter();
+               if (pit != 0)
+                       maxdepth = pars_[pit - 1].getMaxDepthAfter();
 
 
-               if (pit->params().depth() > maxdepth)
-                       pit->params().depth(maxdepth);
+               if (pars_[pit].params().depth() > maxdepth)
+                       pars_[pit].params().depth(maxdepth);
 
                // setCounter can potentially change the labelString.
                setCounter(*bv()->buffer(), pit);
 
                // setCounter can potentially change the labelString.
                setCounter(*bv()->buffer(), pit);
-
-               string const & newLabel = pit->params().labelString();
-
-               if (oldLabel != newLabel)
-                       redoParagraph(pit);
-       }
-}
-
-
-void LyXText::insertInset(InsetOld * inset)
-{
-       if (!cursorPar()->insetAllowed(inset->lyxCode()))
-               return;
-
-       recUndo(cursor.par());
-       freezeUndo();
-       cursorPar()->insertInset(cursor.pos(), inset);
-       // Just to rebreak and refresh correctly.
-       // The character will not be inserted a second time
-       insertChar(Paragraph::META_INSET);
-       // If we enter a highly editable inset the cursor should be before
-       // the inset. After an Undo LyX tries to call inset->edit(...)
-       // and fails if the cursor is behind the inset and getInset
-       // does not return the inset!
-       if (isHighlyEditableInset(inset))
-               cursorLeft(true);
-       
-       unFreezeUndo();
-}
-
-
-void LyXText::cutSelection(bool doclear, bool realcut)
-{
-       // 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
-       // larger the selection the slower LyX will get. This can be
-       // solved by running the line below only when the selection has
-       // finished. The solution used currently just works, to make it
-       // faster we need to be more clever and probably also have more
-       // calls to stuffClipboard. (Lgb)
-       bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
-
-       // This doesn't make sense, if there is no selection
-       if (!selection.set())
-               return;
-
-       // OK, we have a selection. This is always between selection.start
-       // and selection.end
-
-       // make sure that the depth behind the selection are restored, too
-       ParagraphList::iterator endpit = boost::next(getPar(selection.end.par()));
-       ParagraphList::iterator undoendpit = endpit;
-       ParagraphList::iterator pars_end = ownerParagraphs().end();
-
-       if (endpit != pars_end && endpit->getDepth()) {
-               while (endpit != pars_end && endpit->getDepth()) {
-                       ++endpit;
-                       undoendpit = endpit;
+               string const & newLabel = pars_[pit].params().labelString();
+               if (oldLabel != newLabel) {
+                       //lyxerr << "changing labels: old: " << oldLabel << " new: "
+                       //      << newLabel << endl;
+                       redoParagraphInternal(pit);
+                       update_pos = true;
                }
                }
-       } else if (endpit != pars_end) {
-               // because of parindents etc.
-               ++endpit;
        }
        }
-
-       recUndo(selection.start.par(), parOffset(undoendpit) - 1);
-
-       endpit = getPar(selection.end.par());
-       int endpos = selection.end.pos();
-
-       BufferParams const & bufparams = bv()->buffer()->params();
-       boost::tie(endpit, endpos) = realcut ?
-               CutAndPaste::cutSelection(bufparams,
-                                         ownerParagraphs(),
-                                         getPar(selection.start.par()), endpit,
-                                         selection.start.pos(), endpos,
-                                         bufparams.textclass,
-                                         doclear)
-               : CutAndPaste::eraseSelection(bufparams,
-                                             ownerParagraphs(),
-                                             getPar(selection.start.par()), endpit,
-                                             selection.start.pos(), endpos,
-                                             doclear);
-       // sometimes necessary
-       if (doclear)
-               getPar(selection.start.par())->stripLeadingSpaces();
-
-       redoParagraphs(getPar(selection.start.par()), boost::next(endpit));
-       // 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));
-
-       // need a valid cursor. (Lgb)
-       clearSelection();
-
-       setCursor(cursorPar(), cursor.pos());
-       selection.cursor = cursor;
-       updateCounters();
+       if (update_pos)
+               updateParPositions();
 }
 
 
 }
 
 
-void LyXText::copySelection()
+void LyXText::insertInset(LCursor & cur, InsetBase * inset)
 {
 {
-       // 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())
-               return;
-
-       // ok we have a selection. This is always between selection.start
-       // and sel_end cursor
-
-       // copy behind a space if there is one
-       while (getPar(selection.start)->size() > selection.start.pos()
-              && getPar(selection.start)->isLineSeparator(selection.start.pos())
-              && (selection.start.par() != selection.end.par()
-                  || selection.start.pos() < selection.end.pos()))
-               selection.start.pos(selection.start.pos() + 1);
-
-       CutAndPaste::copySelection(getPar(selection.start.par()),
-                                  getPar(selection.end.par()),
-                                  selection.start.pos(), selection.end.pos(),
-                                  bv()->buffer()->params().textclass);
-}
-
-
-void LyXText::pasteSelection(size_t sel_index)
-{
-       // this does not make sense, if there is nothing to paste
-       if (!CutAndPaste::checkPastePossible())
-               return;
-
-       recUndo(cursor.par());
-
-       ParagraphList::iterator endpit;
-       PitPosPair ppp;
-
-       ErrorList el;
-
-       boost::tie(ppp, endpit) =
-               CutAndPaste::pasteSelection(*bv()->buffer(),
-                                           ownerParagraphs(),
-                                           cursorPar(), cursor.pos(),
-                                           bv()->buffer()->params().textclass,
-                                           sel_index, el);
-       bufferErrors(*bv()->buffer(), el);
-       bv()->showErrorList(_("Paste"));
-
-       redoParagraphs(cursorPar(), endpit);
-
-       setCursor(cursor.par(), cursor.pos());
-       clearSelection();
-
-       selection.cursor = cursor;
-       setCursor(ppp.first, ppp.second);
-       setSelection();
-       updateCounters();
-}
-
-
-void LyXText::setSelectionRange(lyx::pos_type length)
-{
-       if (!length)
-               return;
-
-       selection.cursor = cursor;
-       while (length--)
-               cursorRight(true);
-       setSelection();
-}
-
-
-// simple replacing. The font of the first selected character is used
-void LyXText::replaceSelectionWithString(string const & str)
-{
-       recUndo(cursor.par());
-       freezeUndo();
-
-       if (!selection.set()) { // create a dummy selection
-               selection.end = cursor;
-               selection.start = cursor;
-       }
-
-       // Get font setting before we cut
-       pos_type pos = selection.end.pos();
-       LyXFont const font = getPar(selection.start)
-               ->getFontSettings(bv()->buffer()->params(),
-                                 selection.start.pos());
-
-       // Insert the new string
-       string::const_iterator cit = str.begin();
-       string::const_iterator end = str.end();
-       for (; cit != end; ++cit) {
-               getPar(selection.end)->insertChar(pos, (*cit), font);
-               ++pos;
-       }
-
-       // Cut the selection
-       cutSelection(true, false);
-
-       unFreezeUndo();
+       BOOST_ASSERT(this == cur.text());
+       BOOST_ASSERT(inset);
+       cur.paragraph().insertInset(cur.pos(), inset);
+       redoParagraph(cur);
 }
 
 
 // needed to insert the selection
 }
 
 
 // needed to insert the selection
-void LyXText::insertStringAsLines(string const & str)
+void LyXText::insertStringAsLines(LCursor & cur, string const & str)
 {
 {
-       ParagraphList::iterator pit = cursorPar();
-       pos_type pos = cursor.pos();
-       ParagraphList::iterator endpit = boost::next(cursorPar());
-
-       recUndo(cursor.par());
+       par_type pit = cur.par();
+       par_type endpit = cur.par() + 1;
+       pos_type pos = cur.pos();
+       recordUndo(cur);
 
        // only to be sure, should not be neccessary
 
        // only to be sure, should not be neccessary
-       clearSelection();
-
-       bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
+       cur.clearSelection();
+       cur.buffer().insertStringAsLines(pars_, pit, pos, current_font, str);
 
 
-       redoParagraphs(cursorPar(), endpit);
-       setCursor(cursorPar(), cursor.pos());
-       selection.cursor = cursor;
-       setCursor(pit, pos);
-       setSelection();
+       redoParagraphs(cur.par(), endpit);
+       cur.resetAnchor();
+       setCursor(cur, cur.par(), pos);
+       cur.setSelection();
 }
 
 
 }
 
 
-// turns double-CR to single CR, others where converted into one
-// blank. Then InsertStringAsLines is called
-void LyXText::insertStringAsParagraphs(string const & str)
+// turn double CR to single CR, others are converted into one
+// blank. Then insertStringAsLines is called
+void LyXText::insertStringAsParagraphs(LCursor & cur, string const & str)
 {
 {
-       string linestr(str);
+       string linestr = str;
        bool newline_inserted = false;
        bool newline_inserted = false;
-       string::size_type const siz = linestr.length();
 
 
-       for (string::size_type i = 0; i < siz; ++i) {
+       for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
                if (linestr[i] == '\n') {
                        if (newline_inserted) {
                                // we know that \r will be ignored by
                if (linestr[i] == '\n') {
                        if (newline_inserted) {
                                // we know that \r will be ignored by
-                               // InsertStringA. Of course, it is a dirty
+                               // insertStringAsLines. Of course, it is a dirty
                                // trick, but it works...
                                linestr[i - 1] = '\r';
                                linestr[i] = '\n';
                                // trick, but it works...
                                linestr[i - 1] = '\r';
                                linestr[i] = '\n';
@@ -1258,190 +903,111 @@ void LyXText::insertStringAsParagraphs(string const & str)
                        newline_inserted = false;
                }
        }
                        newline_inserted = false;
                }
        }
-       insertStringAsLines(linestr);
-}
-
-
-void LyXText::setCursor(ParagraphList::iterator pit, pos_type pos)
-{
-       setCursor(parOffset(pit), pos);
-}
-
-
-bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont, bool boundary)
-{
-       LyXCursor old_cursor = cursor;
-       setCursorIntern(par, pos, setfont, boundary);
-       return deleteEmptyParagraphMechanism(old_cursor);
+       insertStringAsLines(cur, linestr);
 }
 
 
 }
 
 
-void LyXText::redoCursor()
+bool LyXText::setCursor(LCursor & cur, par_type par, pos_type pos,
+       bool setfont, bool boundary)
 {
 {
-#warning maybe the same for selections?
-       setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
+       LCursor old = cur;
+       setCursorIntern(cur, par, pos, setfont, boundary);
+       return deleteEmptyParagraphMechanism(cur, old);
 }
 
 
 }
 
 
-void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
+void LyXText::setCursor(CursorSlice & cur, par_type par,
        pos_type pos, bool boundary)
 {
        pos_type pos, bool boundary)
 {
-       BOOST_ASSERT(par != int(ownerParagraphs().size()));
+       BOOST_ASSERT(par != int(paragraphs().size()));
 
 
-       cur.par(par);
-       cur.pos(pos);
-       cur.boundary(boundary);
+       cur.par() = par;
+       cur.pos() = pos;
+       cur.boundary() = boundary;
 
        // no rows, no fun...
 
        // no rows, no fun...
-       if (ownerParagraphs().begin()->rows.empty())
+       if (paragraphs().begin()->rows.empty())
                return;
 
                return;
 
-       // get the cursor y position in text
-
-       ParagraphList::iterator pit = getPar(par);
-       Row const & row = *pit->getRow(pos);
-
-       int y = pit->y + row.y_offset();
-
-       // y is now the beginning of the cursor row
-       y += row.baseline();
-       // y is now the cursor baseline
-       cur.y(y);
-
+       // 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
        if (pos < 0) {
                lyxerr << "dont like -1" << endl;
        pos_type const end = row.endpos();
 
        // None of these should happen, but we're scaredy-cats
        if (pos < 0) {
                lyxerr << "dont like -1" << endl;
-               pos = 0;
-               cur.pos(0);
                BOOST_ASSERT(false);
                BOOST_ASSERT(false);
-       } else if (pos > pit->size()) {
+       }
+
+       if (pos > para.size()) {
                lyxerr << "dont like 1, pos: " << pos
                lyxerr << "dont like 1, pos: " << pos
-                      << " size: " << pit->size()
+                      << " size: " << para.size()
                       << " row.pos():" << row.pos()
                       << " row.pos():" << row.pos()
-                      << " paroffset: " << par << endl;
-               pos = 0;
-               cur.pos(0);
+                      << " par: " << par << endl;
                BOOST_ASSERT(false);
                BOOST_ASSERT(false);
-       } else if (pos > end) {
-               lyxerr << "dont like 2 please report" << endl;
+       }
+
+       if (pos > end) {
+               lyxerr << "dont like 2, pos: " << pos
+                      << " size: " << para.size()
+                      << " row.pos():" << row.pos()
+                      << " par: " << par << endl;
                // This shouldn't happen.
                // This shouldn't happen.
-               pos = end;
-               cur.pos(pos);
                BOOST_ASSERT(false);
                BOOST_ASSERT(false);
-       } else if (pos < row.pos()) {
+       }
+
+       if (pos < row.pos()) {
                lyxerr << "dont like 3 please report pos:" << pos
                lyxerr << "dont like 3 please report pos:" << pos
-                      << " size: " << pit->size()
+                      << " size: " << para.size()
                       << " row.pos():" << row.pos()
                       << " row.pos():" << row.pos()
-                      << " paroffset: " << par << endl;
-               pos = row.pos();
-               cur.pos(pos);
+                      << " par: " << par << endl;
                BOOST_ASSERT(false);
        }
                BOOST_ASSERT(false);
        }
-       // now get the cursors x position
-       cur.x(int(getCursorX(pit, row, pos, boundary)));
-}
-
-
-float LyXText::getCursorX(ParagraphList::iterator pit, Row const & row,
-                         pos_type pos, bool boundary) const
-{
-       pos_type cursor_vpos    = 0;
-       double x                = row.x();
-       double fill_separator   = row.fill_separator();
-       double fill_hfill       = row.fill_hfill();
-       double fill_label_hfill = row.fill_label_hfill();
-       pos_type const row_pos  = row.pos();
-       pos_type const end = row.endpos();
-
-       if (end <= row_pos)
-               cursor_vpos = row_pos;
-       else if (pos >= end && !boundary)
-               cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params()))
-                       ? row_pos : end;
-       else if (pos > row_pos && (pos >= end || boundary))
-               // Place cursor after char at (logical) position pos - 1
-               cursor_vpos = (bidi.level(pos - 1) % 2 == 0)
-                       ? bidi.log2vis(pos - 1) + 1 : bidi.log2vis(pos - 1);
-       else
-               // Place cursor before char at (logical) position pos
-               cursor_vpos = (bidi.level(pos) % 2 == 0)
-                       ? bidi.log2vis(pos) : bidi.log2vis(pos) + 1;
-
-       pos_type body_pos = pit->beginOfBody();
-       if (body_pos > 0 &&
-           (body_pos > end || !pit->isLineSeparator(body_pos - 1)))
-               body_pos = 0;
-
-       for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
-               pos_type pos = bidi.vis2log(vpos);
-               if (body_pos > 0 && pos == body_pos - 1) {
-                       x += fill_label_hfill
-                               + font_metrics::width(pit->layout()->labelsep,
-                                                     getLabelFont(pit));
-                       if (pit->isLineSeparator(body_pos - 1))
-                               x -= singleWidth(pit, body_pos - 1);
-               }
-
-               if (hfillExpansion(*pit, row, pos)) {
-                       x += singleWidth(pit, pos);
-                       if (pos >= body_pos)
-                               x += fill_hfill;
-                       else
-                               x += fill_label_hfill;
-               } else if (pit->isSeparator(pos)) {
-                       x += singleWidth(pit, pos);
-                       if (pos >= body_pos)
-                               x += fill_separator;
-               } else
-                       x += singleWidth(pit, pos);
-       }
-       return x;
 }
 
 
 }
 
 
-void LyXText::setCursorIntern(paroffset_type par,
-                             pos_type pos, bool setfont, bool boundary)
+void LyXText::setCursorIntern(LCursor & cur,
+       par_type par, pos_type pos, bool setfont, bool boundary)
 {
 {
-       setCursor(cursor, par, pos, boundary);
-       bv()->x_target(cursor.x() + xo_);
+       setCursor(cur.top(), par, pos, boundary);
+       cur.x_target() = cursorX(cur.top());
        if (setfont)
        if (setfont)
-               setCurrentFont();
+               setCurrentFont(cur);
 }
 
 
 }
 
 
-void LyXText::setCurrentFont()
+void LyXText::setCurrentFont(LCursor & cur)
 {
 {
-       pos_type pos = cursor.pos();
-       ParagraphList::iterator pit = cursorPar();
+       BOOST_ASSERT(this == cur.text());
+       pos_type pos = cur.pos();
+       par_type pit = cur.par();
 
 
-       if (cursor.boundary() && pos > 0)
+       if (cur.boundary() && pos > 0)
                --pos;
 
        if (pos > 0) {
                --pos;
 
        if (pos > 0) {
-               if (pos == pit->size())
+               if (pos == cur.lastpos())
                        --pos;
                else // potentional bug... BUG (Lgb)
                        --pos;
                else // potentional bug... BUG (Lgb)
-                       if (pit->isSeparator(pos)) {
-                               if (pos > pit->getRow(pos)->pos() &&
+                       if (pars_[pit].isSeparator(pos)) {
+                               if (pos > cur.textRow().pos() &&
                                    bidi.level(pos) % 2 ==
                                    bidi.level(pos - 1) % 2)
                                        --pos;
                                    bidi.level(pos) % 2 ==
                                    bidi.level(pos - 1) % 2)
                                        --pos;
-                               else if (pos + 1 < pit->size())
+                               else if (pos + 1 < cur.lastpos())
                                        ++pos;
                        }
        }
 
                                        ++pos;
                        }
        }
 
-       BufferParams const & bufparams = bv()->buffer()->params();
-       current_font = pit->getFontSettings(bufparams, pos);
+       BufferParams const & bufparams = cur.buffer().params();
+       current_font = pars_[pit].getFontSettings(bufparams, pos);
        real_current_font = getFont(pit, pos);
 
        real_current_font = getFont(pit, pos);
 
-       if (cursor.pos() == pit->size() &&
-           bidi.isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
-           !cursor.boundary()) {
-               Language const * lang =
-                       pit->getParLanguage(bufparams);
+       if (cur.pos() == cur.lastpos()
+           && bidi.isBoundary(cur.buffer(), pars_[pit], cur.pos())
+           && !cur.boundary()) {
+               Language const * lang = pars_[pit].getParLanguage(bufparams);
                current_font.setLanguage(lang);
                current_font.setNumber(LyXFont::OFF);
                real_current_font.setLanguage(lang);
                current_font.setLanguage(lang);
                current_font.setNumber(LyXFont::OFF);
                real_current_font.setLanguage(lang);
@@ -1450,34 +1016,34 @@ void LyXText::setCurrentFont()
 }
 
 
 }
 
 
+// x is an absolute screen coord
 // returns the column near the specified x-coordinate of the row
 // x is set to the real beginning of this column
 // returns the column near the specified x-coordinate of the row
 // x is set to the real beginning of this column
-pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
+pos_type LyXText::getColumnNearX(par_type pit,
        Row const & row, int & x, bool & boundary) const
 {
        Row const & row, int & x, bool & boundary) const
 {
-       double tmpx             = row.x();
-       double fill_separator   = row.fill_separator();
-       double fill_hfill       = row.fill_hfill();
-       double fill_label_hfill = row.fill_label_hfill();
+       x -= xo_;
+       RowMetrics const r = computeRowMetrics(pit, row);
 
        pos_type vc = row.pos();
        pos_type end = row.endpos();
        pos_type c = 0;
 
        pos_type vc = row.pos();
        pos_type end = row.endpos();
        pos_type c = 0;
-       LyXLayout_ptr const & layout = pit->layout();
+       LyXLayout_ptr const & layout = pars_[pit].layout();
 
        bool left_side = false;
 
 
        bool left_side = false;
 
-       pos_type body_pos = pit->beginOfBody();
+       pos_type body_pos = pars_[pit].beginOfBody();
+
+       double tmpx = r.x;
        double last_tmpx = tmpx;
 
        if (body_pos > 0 &&
        double last_tmpx = tmpx;
 
        if (body_pos > 0 &&
-           (body_pos > end ||
-            !pit->isLineSeparator(body_pos - 1)))
+           (body_pos > end || !pars_[pit].isLineSeparator(body_pos - 1)))
                body_pos = 0;
 
        // check for empty row
        if (vc == end) {
                body_pos = 0;
 
        // check for empty row
        if (vc == end) {
-               x = int(tmpx);
+               x = int(tmpx) + xo_;
                return 0;
        }
 
                return 0;
        }
 
@@ -1485,22 +1051,22 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
                c = bidi.vis2log(vc);
                last_tmpx = tmpx;
                if (body_pos > 0 && c == body_pos - 1) {
                c = bidi.vis2log(vc);
                last_tmpx = tmpx;
                if (body_pos > 0 && c == body_pos - 1) {
-                       tmpx += fill_label_hfill +
+                       tmpx += r.label_hfill +
                                font_metrics::width(layout->labelsep, getLabelFont(pit));
                                font_metrics::width(layout->labelsep, getLabelFont(pit));
-                       if (pit->isLineSeparator(body_pos - 1))
+                       if (pars_[pit].isLineSeparator(body_pos - 1))
                                tmpx -= singleWidth(pit, body_pos - 1);
                }
 
                                tmpx -= singleWidth(pit, body_pos - 1);
                }
 
-               if (hfillExpansion(*pit, row, c)) {
+               if (hfillExpansion(pars_[pit], row, c)) {
                        tmpx += singleWidth(pit, c);
                        if (c >= body_pos)
                        tmpx += singleWidth(pit, c);
                        if (c >= body_pos)
-                               tmpx += fill_hfill;
+                               tmpx += r.hfill;
                        else
                        else
-                               tmpx += fill_label_hfill;
-               } else if (pit->isSeparator(c)) {
+                               tmpx += r.label_hfill;
+               } else if (pars_[pit].isSeparator(c)) {
                        tmpx += singleWidth(pit, c);
                        if (c >= body_pos)
                        tmpx += singleWidth(pit, c);
                        if (c >= body_pos)
-                               tmpx += fill_separator;
+                               tmpx += r.separator;
                } else {
                        tmpx += singleWidth(pit, c);
                }
                } else {
                        tmpx += singleWidth(pit, c);
                }
@@ -1517,13 +1083,11 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
        boundary = false;
        // This (rtl_support test) is not needed, but gives
        // some speedup if rtl_support == false
        boundary = false;
        // This (rtl_support test) is not needed, but gives
        // some speedup if rtl_support == false
-       bool const lastrow = lyxrc.rtl_support && row.endpos() == pit->size();
+       bool const lastrow = lyxrc.rtl_support && row.endpos() == pars_[pit].size();
 
        // If lastrow is false, we don't need to compute
        // the value of rtl.
 
        // If lastrow is false, we don't need to compute
        // the value of rtl.
-       bool const rtl = (lastrow)
-               ? pit->isRightToLeftPar(bv()->buffer()->params())
-               : false;
+       bool const rtl = lastrow ? isRTL(pars_[pit]) : false;
        if (lastrow &&
                 ((rtl  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
                  (!rtl && !left_side && vc == end  && x > tmpx + 5)))
        if (lastrow &&
                 ((rtl  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
                  (!rtl && !left_side && vc == end  && x > tmpx + 5)))
@@ -1537,11 +1101,11 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
                bool const rtl = (bidi.level(c) % 2 == 1);
                if (left_side == rtl) {
                        ++c;
                bool const rtl = (bidi.level(c) % 2 == 1);
                if (left_side == rtl) {
                        ++c;
-                       boundary = bidi.isBoundary(*bv()->buffer(), *pit, c);
+                       boundary = bidi.isBoundary(*bv()->buffer(), pars_[pit], c);
                }
        }
 
                }
        }
 
-       if (row.pos() < end && c >= end && pit->isNewline(end - 1)) {
+       if (row.pos() < end && c >= end && pars_[pit].isNewline(end - 1)) {
                if (bidi.level(end -1) % 2 == 0)
                        tmpx -= singleWidth(pit, end - 1);
                else
                if (bidi.level(end -1) % 2 == 0)
                        tmpx -= singleWidth(pit, end - 1);
                else
@@ -1549,255 +1113,193 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
                c = end - 1;
        }
 
                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)
+// x,y are absolute coordinates
+void LyXText::setCursorFromCoordinates(LCursor & cur, int x, int y)
 {
 {
-       LyXCursor 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)
-{
-       // Get the row first.
-       ParagraphList::iterator pit;
+       x -= xo_;
+       y -= yo_;
+       par_type pit;
        Row const & row = *getRowNearY(y, pit);
        Row const & row = *getRowNearY(y, pit);
-       y = pit->y + row.y_offset();
-
+       lyxerr << "setCursorFromCoordinates:: hit row at: " << row.pos() << endl;
        bool bound = false;
        bool bound = false;
-       pos_type const column = getColumnNearX(pit, row, x, bound);
-       cur.par(parOffset(pit));
-       cur.pos(row.pos() + column);
-       cur.x(x);
-       cur.y(y + row.baseline());
-
-       cur.boundary(bound);
-}
-
-
-
-bool LyXText::checkAndActivateInset(bool front)
-{
-       if (cursor.pos() == cursorPar()->size())
-               return false;
-       InsetOld * inset = cursorPar()->getInset(cursor.pos());
-       if (!isHighlyEditableInset(inset))
-               return false;
-       inset->edit(bv(), front);
-       return true;
-}
-
-
-DispatchResult LyXText::moveRight()
-{
-       if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
-               return moveLeftIntern(false, true, false);
-       else
-               return moveRightIntern(true, true, false);
-}
-
-
-DispatchResult LyXText::moveLeft()
-{
-       if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
-               return moveRightIntern(true, true, false);
-       else
-               return moveLeftIntern(false, true, false);
+       int xx = x + xo_; // getRowNearX get absolute x coords
+       pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+       setCursor(cur, pit, pos, true, bound);
 }
 
 
 }
 
 
-DispatchResult LyXText::moveRightIntern(bool front, bool activate_inset, bool selecting)
+// x,y are absolute screen coordinates
+InsetBase * LyXText::editXY(LCursor & cur, int x, int y)
 {
 {
-       ParagraphList::iterator c_par = cursorPar();
-       if (boost::next(c_par) == ownerParagraphs().end()
-               && cursor.pos() >= c_par->size())
-               return DispatchResult(false, FINISHED_RIGHT);
-       if (activate_inset && checkAndActivateInset(front))
-               return DispatchResult(true, true);
-       cursorRight(true);
-       if (!selecting)
-               clearSelection();
-       return DispatchResult(true);
-}
-
+       par_type pit;
+       Row const & row = *getRowNearY(y - yo_, pit);
+       bool bound = false;
 
 
-DispatchResult LyXText::moveLeftIntern(bool front,
-                         bool activate_inset, bool selecting)
-{
-       if (cursor.par() == 0 && cursor.pos() <= 0)
-               return DispatchResult(false, FINISHED);
-       cursorLeft(true);
-       if (!selecting)
-               clearSelection();
-       if (activate_inset && checkAndActivateInset(front))
-               return DispatchResult(true, true);
-       return DispatchResult(true);
-}
+       int xx = x; // is modified by getColumnNearX
+       pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+       cur.par() = pit;
+       cur.pos() = pos;
+       cur.boundary() = bound;
 
 
+       // try to descend into nested insets
+       InsetBase * inset = checkInsetHit(x, y);
+       lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
+       if (!inset)
+               return 0;
 
 
-DispatchResult LyXText::moveUp()
-{
-       if (cursorRow() == firstRow())
-               return DispatchResult(false, FINISHED_UP);
-       cursorUp(false);
-       clearSelection();
-       return DispatchResult(true);
+       // This should be just before or just behind the
+       // cursor position set above.
+       BOOST_ASSERT((pos != 0 && inset == pars_[pit].getInset(pos - 1))
+                    || inset == pars_[pit].getInset(pos));
+       // Make sure the cursor points to the position before
+       // this inset.
+       if (inset == pars_[pit].getInset(pos - 1))
+               --cur.pos();
+       return inset->editXY(cur, x, y);
 }
 
 
 }
 
 
-DispatchResult LyXText::moveDown()
+bool LyXText::checkAndActivateInset(LCursor & cur, bool front)
 {
 {
-       if (cursorRow() == lastRow())
-               return DispatchResult(false, FINISHED_DOWN);
-       cursorDown(false);
-       clearSelection();
-       return DispatchResult(true);
+       if (cur.selection())
+               return false;
+       if (cur.pos() == cur.lastpos())
+               return false;
+       InsetBase * inset = cur.nextInset();
+       if (!isHighlyEditableInset(inset))
+               return false;
+       inset->edit(cur, front);
+       return true;
 }
 
 
 }
 
 
-bool LyXText::cursorLeft(bool internal)
+void LyXText::cursorLeft(LCursor & cur)
 {
 {
-       if (cursor.pos() > 0) {
-               bool boundary = cursor.boundary();
-               setCursor(cursor.par(), cursor.pos() - 1, true, false);
-               if (!internal && !boundary &&
-                   bidi.isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
-                       setCursor(cursor.par(), cursor.pos() + 1, true, true);
-               return true;
+       if (cur.pos() != 0) {
+               bool boundary = cur.boundary();
+               setCursor(cur, cur.par(), cur.pos() - 1, true, false);
+               if (!checkAndActivateInset(cur, false)) {
+                       if (false && !boundary &&
+                                       bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
+                               setCursor(cur, cur.par(), cur.pos() + 1, true, true);
+               }
+               return;
        }
 
        }
 
-       if (cursor.par() != 0) {
+       if (cur.par() != 0) {
                // steps into the paragraph above
                // steps into the paragraph above
-               setCursor(cursor.par() - 1, boost::prior(cursorPar())->size());
-               return true;
+               setCursor(cur, cur.par() - 1, getPar(cur.par() - 1).size());
        }
        }
-
-       return false;
 }
 
 
 }
 
 
-bool LyXText::cursorRight(bool internal)
+void LyXText::cursorRight(LCursor & cur)
 {
 {
-       if (!internal && cursor.boundary()) {
-               setCursor(cursor.par(), cursor.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);
-               return true;
+       if (false && cur.boundary()) {
+               setCursor(cur, cur.par(), cur.pos(), true, false);
+               return;
        }
 
        }
 
-       if (cursor.par() + 1 != int(ownerParagraphs().size())) {
-               setCursor(cursor.par() + 1, 0);
-               return true;
+       if (cur.pos() != cur.lastpos()) {
+               if (!checkAndActivateInset(cur, true)) {
+                       setCursor(cur, cur.par(), cur.pos() + 1, true, false);
+                       if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
+                                                        cur.pos()))
+                               setCursor(cur, cur.par(), cur.pos(), true, true);
+               }
+               return;
        }
 
        }
 
-       return false;
+       if (cur.par() != cur.lastpar())
+               setCursor(cur, cur.par() + 1, 0);
 }
 
 
 }
 
 
-void LyXText::cursorUp(bool selecting)
+void LyXText::cursorUp(LCursor & cur)
 {
 {
-       Row const & row = *cursorRow();
-       int x = bv()->x_target() - xo_;
-       int y = cursor.y() - 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);
+       Row const & row = cur.textRow();
+       int x = cur.x_target();
+       int y = cursorY(cur.top()) - row.baseline() - 1;
+       setCursorFromCoordinates(cur, x, y);
+
+       if (!cur.selection()) {
+               InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
                if (inset_hit && isHighlyEditableInset(inset_hit))
                if (inset_hit && isHighlyEditableInset(inset_hit))
-                       inset_hit->edit(bv(), bv()->x_target(), y_abs);
+                       inset_hit->editXY(cur, cur.x_target(), y);
        }
 }
 
 
        }
 }
 
 
-void LyXText::cursorDown(bool selecting)
+void LyXText::cursorDown(LCursor & cur)
 {
 {
-       Row const & row = *cursorRow();
-       int x = bv()->x_target() - xo_;
-       int y = cursor.y() - 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);
+       Row const & row = cur.textRow();
+       int x = cur.x_target();
+       int y = cursorY(cur.top()) - row.baseline() + row.height() + 1;
+       setCursorFromCoordinates(cur, x, y);
+
+       if (!cur.selection()) {
+               InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
                if (inset_hit && isHighlyEditableInset(inset_hit))
                if (inset_hit && isHighlyEditableInset(inset_hit))
-                       inset_hit->edit(bv(), bv()->x_target(), y_abs);
+                       inset_hit->editXY(cur, cur.x_target(), y);
        }
 }
 
 
        }
 }
 
 
-void LyXText::cursorUpParagraph()
+void LyXText::cursorUpParagraph(LCursor & cur)
 {
 {
-       ParagraphList::iterator cpit = cursorPar();
-       if (cursor.pos() > 0)
-               setCursor(cpit, 0);
-       else if (cpit != ownerParagraphs().begin())
-               setCursor(boost::prior(cpit), 0);
+       if (cur.pos() > 0)
+               setCursor(cur, cur.par(), 0);
+       else if (cur.par() != 0)
+               setCursor(cur, cur.par() - 1, 0);
 }
 
 
 }
 
 
-void LyXText::cursorDownParagraph()
+void LyXText::cursorDownParagraph(LCursor & cur)
 {
 {
-       ParagraphList::iterator pit = cursorPar();
-       ParagraphList::iterator next_pit = boost::next(pit);
-
-       if (next_pit != ownerParagraphs().end())
-               setCursor(next_pit, 0);
+       if (cur.par() != cur.lastpar())
+               setCursor(cur, cur.par() + 1, 0);
        else
        else
-               setCursor(pit, pit->size());
+               setCursor(cur, cur.par(), cur.lastpos());
 }
 
 
 // fix the cursor `cur' after a characters has been deleted at `where'
 // position. Called by deleteEmptyParagraphMechanism
 }
 
 
 // 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
+       // do notheing if cursor is not in the paragraph where the
+       // deletion occured,
        if (cur.par() != where.par())
                return;
 
        if (cur.par() != where.par())
                return;
 
-       // if cursor position is after the place where the delete occured,
-       // update it
+       // if cursor position is after the deletion place update it
        if (cur.pos() > where.pos())
        if (cur.pos() > where.pos())
-               cur.pos(cur.pos()-1);
+               --cur.pos();
 
        // check also if we don't want to set the cursor on a spot behind the
        // pagragraph because we erased the last character.
 
        // 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());
-
-       // recompute row et al. for this cursor
-       setCursor(cur, cur.par(), cur.pos(), cur.boundary());
+       if (cur.pos() > cur.lastpos())
+               cur.pos() = cur.lastpos();
 }
 
 
 }
 
 
-bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
+bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor const & old)
 {
 {
+       BOOST_ASSERT(cur.size() == old.size());
        // Would be wrong to delete anything if we have a selection.
        // Would be wrong to delete anything if we have a selection.
-       if (selection.set())
+       if (cur.selection())
                return false;
 
                return false;
 
-       // Don't do anything if the cursor is invalid
-       if (old_cursor.par() == -1)
-               return false;
+       //lyxerr << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+       Paragraph const & oldpar = pars_[old.par()];
 
        // We allow all kinds of "mumbo-jumbo" when freespacing.
 
        // We allow all kinds of "mumbo-jumbo" when freespacing.
-       ParagraphList::iterator const old_pit = getPar(old_cursor);
-       if (old_pit->isFreeSpacing())
+       if (oldpar.isFreeSpacing())
                return false;
 
        /* Ok I'll put some comments here about what is missing.
                return false;
 
        /* Ok I'll put some comments here about what is missing.
@@ -1806,7 +1308,7 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
           Copy and Paste to hopefully do some sensible things.
           There are still some small problems that can lead to
           double spaces stored in the document file or space at
           Copy and Paste to hopefully do some sensible things.
           There are still some small problems that can lead to
           double spaces stored in the document file or space at
-          the beginning of paragraphs. This happens if you have
+          the beginning of paragraphs(). This happens if you have
           the cursor between to spaces and then save. Or if you
           cut and paste and the selection have a space at the
           beginning and then save right after the paste. I am
           the cursor between to spaces and then save. Or if you
           cut and paste and the selection have a space at the
           beginning and then save right after the paste. I am
@@ -1815,137 +1317,113 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
           that I can get some feedback. (Lgb)
        */
 
           that I can get some feedback. (Lgb)
        */
 
-       // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
+       // If old.pos() == 0 and old.pos()(1) == LineSeparator
        // delete the LineSeparator.
        // MISSING
 
        // delete the LineSeparator.
        // MISSING
 
-       // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
+       // If old.pos() == 1 and old.pos()(0) == LineSeparator
        // delete the LineSeparator.
        // MISSING
 
        // delete the LineSeparator.
        // 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()) {
-
-               // Only if the cursor has really moved
-               if (old_cursor.pos() > 0
-                   && old_cursor.pos() < old_pit->size()
-                   && old_pit->isLineSeparator(old_cursor.pos())
-                   && old_pit->isLineSeparator(old_cursor.pos() - 1)) {
-                       bool erased = old_pit->erase(old_cursor.pos() - 1);
-                       redoParagraph(old_pit);
+       // If the chars around the old cursor were spaces, delete one of them.
+       if (old.par() != cur.par() || old.pos() != cur.pos()) {
 
 
-                       if (!erased)
-                               return false;
+               // Only if the cursor has really moved.
+               if (old.pos() > 0
+                   && old.pos() < oldpar.size()
+                   && oldpar.isLineSeparator(old.pos())
+                   && oldpar.isLineSeparator(old.pos() - 1)) {
+                       pars_[old.par()].erase(old.pos() - 1);
 #ifdef WITH_WARNINGS
 #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
 #ifdef WITH_WARNINGS
 #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
 #endif
-                       // correct all cursors held by the LyXText
-                       fixCursorAfterDelete(cursor, old_cursor);
-                       fixCursorAfterDelete(selection.cursor, old_cursor);
-                       fixCursorAfterDelete(selection.start, old_cursor);
-                       fixCursorAfterDelete(selection.end, old_cursor);
+                       // correct all cursor parts
+                       fixCursorAfterDelete(cur.top(), old.top());
+#warning DEPM, look here
+                       //fixCursorAfterDelete(cur.anchor(), old.top());
                        return false;
                }
        }
 
                        return false;
                }
        }
 
-       // don't delete anything if this is the ONLY paragraph!
-       if (ownerParagraphs().size() == 1)
+       // only do our magic if we changed paragraph
+       if (old.par() == cur.par())
                return false;
 
                return false;
 
-       // Do not delete empty paragraphs with keepempty set.
-       if (old_pit->allowEmpty())
+       // don't delete anything if this is the ONLY paragraph!
+       if (pars_.size() == 1)
                return false;
 
                return false;
 
-       // only do our magic if we changed paragraph
-       if (old_cursor.par() == cursor.par())
+       // Do not delete empty paragraphs with keepempty set.
+       if (oldpar.allowEmpty())
                return false;
 
        // record if we have deleted a paragraph
        // we can't possibly have deleted a paragraph before this point
        bool deleted = false;
 
                return false;
 
        // record if we have deleted a paragraph
        // we can't possibly have deleted a paragraph before this point
        bool deleted = false;
 
-       if (old_pit->empty()
-           || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
+       if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
                // ok, we will delete something
                // ok, we will delete something
-               LyXCursor tmpcursor;
+               CursorSlice tmpcursor;
 
                deleted = true;
 
                bool selection_position_was_oldcursor_position =
 
                deleted = true;
 
                bool selection_position_was_oldcursor_position =
-                       selection.cursor.par() == old_cursor.par()
-                       && selection.cursor.pos() == old_cursor.pos();
+                       cur.anchor().par() == old.par() && cur.anchor().pos() == old.pos();
 
 
-               tmpcursor = cursor;
-               cursor = old_cursor; // that undo can restore the right cursor position
+               // This is a bit of a overkill. We change the old and the cur par
+               // at max, certainly not everything in between...
+               recUndo(old.par(), cur.par());
 
 
-               ParagraphList::iterator endpit = boost::next(old_pit);
-               while (endpit != ownerParagraphs().end() && endpit->getDepth())
-                       ++endpit;
+               // Delete old par.
+               pars_.erase(pars_.begin() + old.par());
 
 
-               recUndo(parOffset(old_pit), parOffset(endpit) - 1);
-               cursor = tmpcursor;
-
-               // cache cursor pit
-               ParagraphList::iterator tmppit = cursorPar();
-               // delete old par
-               ownerParagraphs().erase(old_pit);
-               // update cursor par offset
-               cursor.par(parOffset(tmppit));
-               redoParagraph();
-
-               // correct cursor y
-               setCursorIntern(cursor.par(), cursor.pos());
+               // Update cursor par offset if necessary.
+               // Some 'iterator registration' would be nice that takes care of
+               // such events. Maybe even signal/slot?
+               if (cur.par() > old.par())
+                       --cur.par();
+#warning DEPM, look here
+//             if (cur.anchor().par() > old.par())
+//                     --cur.anchor().par();
 
                if (selection_position_was_oldcursor_position) {
                        // correct selection
 
                if (selection_position_was_oldcursor_position) {
                        // correct selection
-                       selection.cursor = cursor;
+                       cur.resetAnchor();
                }
        }
 
        if (deleted)
                return true;
 
                }
        }
 
        if (deleted)
                return true;
 
-       if (old_pit->stripLeadingSpaces()) {
-               redoParagraph(old_pit);
-               // correct cursor y
-               setCursorIntern(cursor.par(), cursor.pos());
-               selection.cursor = cursor;
-       }
-       return false;
-}
-
+       if (pars_[old.par()].stripLeadingSpaces())
+               cur.resetAnchor();
 
 
-ParagraphList & LyXText::ownerParagraphs() const
-{
-       return *paragraphs_;
+       return false;
 }
 
 
 }
 
 
-void LyXText::recUndo(paroffset_type first, paroffset_type last) const
+ParagraphList & LyXText::paragraphs() const
 {
 {
-       recordUndo(Undo::ATOMIC, this, first, last);
+       return const_cast<ParagraphList &>(pars_);
 }
 
 
 }
 
 
-void LyXText::recUndo(lyx::paroffset_type par) const
+void LyXText::recUndo(par_type first, par_type last) const
 {
 {
-       recordUndo(Undo::ATOMIC, this, par, par);
+       recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
 }
 
 
 }
 
 
-bool LyXText::isInInset() const
+void LyXText::recUndo(par_type par) const
 {
 {
-       // Sub-level has non-null bv owner and non-null inset owner.
-       return inset_owner != 0;
+       recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
 }
 
 
 int defaultRowHeight()
 {
 }
 
 
 int defaultRowHeight()
 {
-       LyXFont const font(LyXFont::ALL_SANE);
-       return int(font_metrics::maxHeight(font) *  1.2);
+       return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) *  1.2);
 }
 }