X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText2.cpp;h=96d1035243bab5915cbbda9b5e18e04ca3e3534a;hb=57b69a5efddf9f3c148007322f00dad6c253a2ed;hp=4c47d0811f6c66f8b956755fe9390d0a78f0ea33;hpb=2ea432bab156751d40f2909f73db857942cfa143;p=lyx.git

diff --git a/src/Text2.cpp b/src/Text2.cpp
index 4c47d0811f..96d1035243 100644
--- a/src/Text2.cpp
+++ b/src/Text2.cpp
@@ -4,16 +4,16 @@
  * Licence details can be found in the file COPYING.
  *
  * \author Asger Alstrup
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
  * \author Alfredo Braunstein
  * \author Jean-Marc Lasgouttes
  * \author Angus Leeming
  * \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
  * \author Allan Rae
  * \author Stefan Schimanski
  * \author Dekel Tsur
- * \author Jürgen Vigna
+ * \author Jürgen Vigna
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -27,114 +27,103 @@
 #include "BufferList.h"
 #include "BufferParams.h"
 #include "BufferView.h"
-#include "Bullet.h"
-#include "Color.h"
+#include "Changes.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
-#include "debug.h"
 #include "DispatchResult.h"
 #include "ErrorList.h"
-#include "FuncRequest.h"
-#include "gettext.h"
 #include "Language.h"
+#include "Layout.h"
 #include "Lexer.h"
-#include "LyXFunc.h"
+#include "LyX.h"
 #include "LyXRC.h"
 #include "Paragraph.h"
-#include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
-#include "ParIterator.h"
-#include "Server.h"
-#include "ServerSocket.h"
-#include "Undo.h"
-#include "VSpace.h"
+#include "TextClass.h"
+#include "TextMetrics.h"
 
-#include "frontends/FontMetrics.h"
-
-#include "insets/InsetEnvironment.h"
+#include "insets/InsetCollapsable.h"
 
 #include "mathed/InsetMathHull.h"
 
+#include "support/lassert.h"
+#include "support/debug.h"
+#include "support/gettext.h"
+#include "support/lyxalgo.h"
 #include "support/textutils.h"
 
-#include <boost/current_function.hpp>
-
 #include <sstream>
 
-using std::endl;
-using std::ostringstream;
-using std::string;
-using std::max;
-using std::min;
-using std::istringstream;
+using namespace std;
 
 namespace lyx {
 
-Text::Text()
-	: autoBreakRows_(false)
-{}
-
-
-bool Text::isMainText(Buffer const & buffer) const
+bool Text::isMainText() const
 {
-	return &buffer.text() == this;
+	return &owner_->buffer().text() == this;
 }
 
 
-Font Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::layoutFont(pit_type const pit) const
 {
-	LayoutPtr const & layout = pars_[pit].layout();
+	Layout const & layout = pars_[pit].layout();
 
 	if (!pars_[pit].getDepth())  {
-		Font lf = layout->resfont;
+		FontInfo lf = layout.resfont;
 		// In case the default family has been customized
-		if (layout->font.family() == Font::INHERIT_FAMILY)
-			lf.setFamily(buffer.params().getFont().family());
-		return lf;
+		if (layout.font.family() == INHERIT_FAMILY)
+			lf.setFamily(owner_->buffer().params().getFont().fontInfo().family());
+		FontInfo icf = owner_->getLayout().font();
+		icf.realize(lf);
+		return icf;
 	}
 
-	Font font = layout->font;
+	FontInfo font = layout.font;
 	// Realize with the fonts of lesser depth.
-	//font.realize(outerFont(pit, paragraphs()));
-	font.realize(buffer.params().getFont());
+	//font.realize(outerFont(pit));
+	font.realize(owner_->buffer().params().getFont().fontInfo());
 
 	return font;
 }
 
 
-Font Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::labelFont(Paragraph const & par) const
 {
-	LayoutPtr const & layout = par.layout();
+	Buffer const & buffer = owner_->buffer();
+	Layout const & layout = par.layout();
 
 	if (!par.getDepth()) {
-		Font lf = layout->reslabelfont;
+		FontInfo lf = layout.reslabelfont;
 		// In case the default family has been customized
-		if (layout->labelfont.family() == Font::INHERIT_FAMILY)
-			lf.setFamily(buffer.params().getFont().family());
+		if (layout.labelfont.family() == INHERIT_FAMILY)
+			lf.setFamily(buffer.params().getFont().fontInfo().family());
 		return lf;
 	}
 
-	Font font = layout->labelfont;
+	FontInfo font = layout.labelfont;
 	// Realize with the fonts of lesser depth.
-	font.realize(buffer.params().getFont());
+	font.realize(buffer.params().getFont().fontInfo());
 
 	return font;
 }
 
 
-void Text::setCharFont(Buffer const & buffer, pit_type pit,
+void Text::setCharFont(pit_type pit,
 		pos_type pos, Font const & fnt, Font const & display_font)
 {
+	Buffer const & buffer = owner_->buffer();
 	Font font = fnt;
-	LayoutPtr const & layout = pars_[pit].layout();
+	Layout const & layout = pars_[pit].layout();
 
 	// Get concrete layout font to reduce against
-	Font layoutfont;
+	FontInfo layoutfont;
 
 	if (pos < pars_[pit].beginOfBody())
-		layoutfont = layout->labelfont;
+		layoutfont = layout.labelfont;
 	else
-		layoutfont = layout->font;
+		layoutfont = layout.font;
 
 	// Realize against environment font information
 	if (pars_[pit].getDepth()) {
@@ -142,33 +131,32 @@ void Text::setCharFont(Buffer const & buffer, pit_type pit,
 		while (!layoutfont.resolved() &&
 		       tp != pit_type(paragraphs().size()) &&
 		       pars_[tp].getDepth()) {
-			tp = outerHook(tp, paragraphs());
+			tp = outerHook(tp);
 			if (tp != pit_type(paragraphs().size()))
-				layoutfont.realize(pars_[tp].layout()->font);
+				layoutfont.realize(pars_[tp].layout().font);
 		}
 	}
 
 	// Inside inset, apply the inset's font attributes if any
 	// (charstyle!)
-	if (!isMainText(buffer))
-		layoutfont.realize(display_font);
+	if (!isMainText())
+		layoutfont.realize(display_font.fontInfo());
 
-	layoutfont.realize(buffer.params().getFont());
+	layoutfont.realize(buffer.params().getFont().fontInfo());
 
 	// Now, reduce font against full layout font
-	font.reduce(layoutfont);
+	font.fontInfo().reduce(layoutfont);
 
 	pars_[pit].setFont(pos, font);
 }
 
 
 void Text::setInsetFont(BufferView const & bv, pit_type pit,
-		pos_type pos, Font const & font, bool toggleall)
+		pos_type pos, Font const & font)
 {
-	BOOST_ASSERT(pars_[pit].isInset(pos) &&
-		     pars_[pit].getInset(pos)->noFontChange());
-
 	Inset * const inset = pars_[pit].getInset(pos);
+	LASSERT(inset && inset->resetFontEdit(), return);
+
 	CursorSlice::idx_type endidx = inset->nargs();
 	for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
 		Text * text = cs.text();
@@ -177,45 +165,26 @@ void Text::setInsetFont(BufferView const & bv, pit_type pit,
 			CursorSlice cellend = cs;
 			cellend.pit() = cellend.lastpit();
 			cellend.pos() = cellend.lastpos();
-			text->setFont(bv, cs, cellend, font, toggleall);
+			text->setFont(bv, cs, cellend, font);
 		}
 	}
 }
 
 
-// return past-the-last paragraph influenced by a layout change on pit
-pit_type Text::undoSpan(pit_type pit)
-{
-	pit_type end = paragraphs().size();
-	pit_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;
-}
-
-
-void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
-		docstring const & layout)
+void Text::setLayout(pit_type start, pit_type end,
+		     docstring const & layout)
 {
-	BOOST_ASSERT(start != end);
+	LASSERT(start != end, return);
 
-	BufferParams const & bufparams = buffer.params();
-	LayoutPtr const & lyxlayout = bufparams.getTextClass()[layout];
+	Buffer const & buffer = owner_->buffer();
+	BufferParams const & bp = buffer.params();
+	Layout const & lyxlayout = bp.documentClass()[layout];
 
 	for (pit_type pit = start; pit != end; ++pit) {
 		Paragraph & par = pars_[pit];
 		par.applyLayout(lyxlayout);
-		if (lyxlayout->margintype == MARGIN_MANUAL)
-			par.setLabelWidthString(par.translateIfPossible(
-				lyxlayout->labelstring(), buffer.params()));
+		if (lyxlayout.margintype == MARGIN_MANUAL)
+			par.setLabelWidthString(par.expandLabel(lyxlayout, bp));
 	}
 }
 
@@ -223,38 +192,20 @@ void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
 // set layout over selection and make a total rebreak of those paragraphs
 void Text::setLayout(Cursor & cur, docstring const & layout)
 {
-	BOOST_ASSERT(this == cur.text());
-	// special handling of new environment insets
-	BufferView & bv = cur.bv();
-	BufferParams const & params = bv.buffer().params();
-	LayoutPtr const & lyxlayout = params.getTextClass()[layout];
-	if (lyxlayout->is_environment) {
-		// move everything in a new environment inset
-		LYXERR(Debug::DEBUG) << "setting layout " << to_utf8(layout) << endl;
-		lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
-		lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
-		lyx::dispatch(FuncRequest(LFUN_CUT));
-		Inset * inset = new InsetEnvironment(params, layout);
-		insertInset(cur, inset);
-		//inset->edit(cur, true);
-		//lyx::dispatch(FuncRequest(LFUN_PASTE));
-		return;
-	}
+	LBUFERR(this == cur.text());
 
 	pit_type start = cur.selBegin().pit();
 	pit_type end = cur.selEnd().pit() + 1;
-	pit_type undopit = undoSpan(end - 1);
-	recUndo(cur, start, undopit - 1);
-	setLayout(cur.buffer(), start, end, layout);
-	updateLabels(cur.buffer());
+	cur.recordUndoSelection();
+	setLayout(start, end, layout);
+	cur.setCurrentFont();
+	cur.forceBufferUpdate();
 }
 
 
 static bool changeDepthAllowed(Text::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 == Text::INC_DEPTH && depth < max_depth)
 		return true;
@@ -266,7 +217,7 @@ static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
 
 bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
 {
-	BOOST_ASSERT(this == cur.text());
+	LBUFERR(this == cur.text());
 	// this happens when selecting several cells in tabular (bug 2630)
 	if (cur.selBegin().idx() != cur.selEnd().idx())
 		return false;
@@ -286,10 +237,10 @@ bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
 
 void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
 {
-	BOOST_ASSERT(this == cur.text());
+	LBUFERR(this == cur.text());
 	pit_type const beg = cur.selBegin().pit();
 	pit_type const end = cur.selEnd().pit() + 1;
-	recordUndoSelection(cur);
+	cur.recordUndoSelection();
 	int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
 
 	for (pit_type pit = beg; pit != end; ++pit) {
@@ -305,48 +256,104 @@ void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
 	}
 	// this handles the counter labels, and also fixes up
 	// depth values for follow-on (child) paragraphs
-	updateLabels(cur.buffer());
+	cur.forceBufferUpdate();
 }
 
 
 void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), return);
+
+	// If there is a selection, record undo before the cursor font is changed.
+	if (cur.selection())
+		cur.recordUndoSelection();
+
 	// Set the current_font
 	// Determine basis font
-	Font layoutfont;
+	FontInfo layoutfont;
 	pit_type pit = cur.pit();
 	if (cur.pos() < pars_[pit].beginOfBody())
-		layoutfont = getLabelFont(cur.buffer(), pars_[pit]);
+		layoutfont = labelFont(pars_[pit]);
 	else
-		layoutfont = getLayoutFont(cur.buffer(), pit);
+		layoutfont = layoutFont(pit);
 
 	// Update current font
 	cur.real_current_font.update(font,
-					cur.buffer().params().language,
+					cur.buffer()->params().language,
 					toggleall);
 
 	// Reduce to implicit settings
 	cur.current_font = cur.real_current_font;
-	cur.current_font.reduce(layoutfont);
+	cur.current_font.fontInfo().reduce(layoutfont);
 	// And resolve it completely
-	cur.real_current_font.realize(layoutfont);
+	cur.real_current_font.fontInfo().realize(layoutfont);
 
 	// if there is no selection that's all we need to do
 	if (!cur.selection())
 		return;
 
 	// Ok, we have a selection.
-	recordUndoSelection(cur);
+	Font newfont = font;
+
+	if (toggleall) {	
+		// Toggling behaves as follows: We check the first character of the
+		// selection. If it's (say) got EMPH on, then we set to off; if off,
+		// then to on. With families and the like, we set it to INHERIT, if
+		// we already have it.
+		CursorSlice const & sl = cur.selBegin();
+		Text const & text = *sl.text();
+		Paragraph const & par = text.getPar(sl.pit());
+	
+		// get font at the position
+		Font oldfont = par.getFont(cur.bv().buffer().params(), sl.pos(),
+			text.outerFont(sl.pit()));
+		FontInfo const & oldfi = oldfont.fontInfo();
+	
+		FontInfo & newfi = newfont.fontInfo();
+	
+		FontFamily newfam = newfi.family();
+		if (newfam !=	INHERIT_FAMILY && newfam != IGNORE_FAMILY &&
+				newfam == oldfi.family())
+			newfi.setFamily(INHERIT_FAMILY);
+		
+		FontSeries newser = newfi.series();
+		if (newser == BOLD_SERIES && oldfi.series() == BOLD_SERIES)
+			newfi.setSeries(INHERIT_SERIES);
+	
+		FontShape newshp = newfi.shape();
+		if (newshp != INHERIT_SHAPE && newshp != IGNORE_SHAPE &&
+				newshp == oldfi.shape())
+			newfi.setShape(INHERIT_SHAPE);
+
+		ColorCode newcol = newfi.color();
+		if (newcol != Color_none && newcol != Color_inherit 
+		    && newcol != Color_ignore && newcol == oldfi.color())
+			newfi.setColor(Color_none);
+
+		// ON/OFF ones
+		if (newfi.emph() == FONT_TOGGLE)
+			newfi.setEmph(oldfi.emph() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.underbar() == FONT_TOGGLE)
+			newfi.setUnderbar(oldfi.underbar() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.strikeout() == FONT_TOGGLE)
+			newfi.setStrikeout(oldfi.strikeout() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.uuline() == FONT_TOGGLE)
+			newfi.setUuline(oldfi.uuline() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.uwave() == FONT_TOGGLE)
+			newfi.setUwave(oldfi.uwave() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.noun() == FONT_TOGGLE)
+			newfi.setNoun(oldfi.noun() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.number() == FONT_TOGGLE)
+			newfi.setNumber(oldfi.number() == FONT_OFF ? FONT_ON : FONT_OFF);
+	}
 
 	setFont(cur.bv(), cur.selectionBegin().top(), 
-		cur.selectionEnd().top(), font, toggleall);
+		cur.selectionEnd().top(), newfont);
 }
 
 
 void Text::setFont(BufferView const & bv, CursorSlice const & begin,
-		CursorSlice const & end, Font const & font,
-		bool toggleall)
+		CursorSlice const & end, Font const & font)
 {
 	Buffer const & buffer = bv.buffer();
 
@@ -356,44 +363,46 @@ void Text::setFont(BufferView const & bv, CursorSlice const & begin,
 	// nested insets.
 	Language const * language = buffer.params().language;
 	for (CursorSlice dit = begin; dit != end; dit.forwardPos()) {
-		if (dit.pos() != dit.lastpos()) {
-			pit_type const pit = dit.pit();
-			pos_type const pos = dit.pos();
-			if (pars_[pit].isInset(pos) &&
-			    pars_[pit].getInset(pos)->noFontChange())
-				// We need to propagate the font change to all
-				// text cells of the inset (bug 1973).
-				// FIXME: This should change, see documentation
-				// of noFontChange in Inset.h
-				setInsetFont(bv, pit, pos, font, toggleall);
-			TextMetrics const & tm = bv.textMetrics(this);
-			Font f = tm.getDisplayFont(pit, pos);
-			f.update(font, language, toggleall);
-			setCharFont(buffer, pit, pos, f, tm.font_);
+		if (dit.pos() == dit.lastpos())
+			continue;
+		pit_type const pit = dit.pit();
+		pos_type const pos = dit.pos();
+		Inset * inset = pars_[pit].getInset(pos);
+		if (inset && inset->resetFontEdit()) {
+			// We need to propagate the font change to all
+			// text cells of the inset (bugs 1973, 6919).
+			setInsetFont(bv, pit, pos, font);
 		}
+		TextMetrics const & tm = bv.textMetrics(this);
+		Font f = tm.displayFont(pit, pos);
+		f.update(font, language);
+		setCharFont(pit, pos, f, tm.font_);
+		// font change may change language... 
+		// spell checker has to know that
+		pars_[pit].requestSpellCheck(pos);
 	}
 }
 
 
 bool Text::cursorTop(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LBUFERR(this == cur.text());
 	return setCursor(cur, 0, 0);
 }
 
 
 bool Text::cursorBottom(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
-	return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
+	LBUFERR(this == cur.text());
+	return setCursor(cur, cur.lastpit(), prev(paragraphs().end(), 1)->size());
 }
 
 
 void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 {
-	BOOST_ASSERT(this == cur.text());
+	LBUFERR(this == cur.text());
 	// If the mask is completely neutral, tell user
-	if (font == Font(Font::ALL_IGNORE)) {
+	if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
 		// Could only happen with user style
 		cur.message(_("No font change defined."));
 		return;
@@ -402,10 +411,10 @@ void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 	// Try implicit word selection
 	// If there is a change in the language the implicit word selection
 	// is disabled.
-	CursorSlice resetCursor = cur.top();
-	bool implicitSelection =
+	CursorSlice const resetCursor = cur.top();
+	bool const implicitSelection =
 		font.language() == ignore_language
-		&& font.number() == Font::IGNORE
+		&& font.fontInfo().number() == FONT_IGNORE
 		&& selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
 
 	// Set font
@@ -423,152 +432,138 @@ void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 
 docstring Text::getStringToIndex(Cursor const & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LBUFERR(this == cur.text());
 
-	docstring idxstring;
 	if (cur.selection())
-		idxstring = cur.selectionAsString(false);
-	else {
-		// Try implicit word selection. If there is a change
-		// in the language the implicit word selection is
-		// disabled.
-		Cursor tmpcur = cur;
-		selectWord(tmpcur, PREVIOUS_WORD);
-
-		if (!tmpcur.selection())
-			cur.message(_("Nothing to index!"));
-		else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
-			cur.message(_("Cannot index more than one paragraph!"));
-		else
-			idxstring = tmpcur.selectionAsString(false);
+		return cur.selectionAsString(false);
+
+	// Try implicit word selection. If there is a change
+	// in the language the implicit word selection is
+	// disabled.
+	Cursor tmpcur = cur;
+	selectWord(tmpcur, PREVIOUS_WORD);
+
+	if (!tmpcur.selection())
+		cur.message(_("Nothing to index!"));
+	else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
+		cur.message(_("Cannot index more than one paragraph!"));
+	else
+		return tmpcur.selectionAsString(false);
+	
+	return docstring();
+}
+
+
+void Text::setLabelWidthStringToSequence(Cursor const & cur,
+		docstring const & s)
+{
+	Cursor c = cur;
+	// Find first of same layout in sequence
+	while (!isFirstInSequence(c.pit())) {
+		c.pit() = depthHook(c.pit(), c.paragraph().getDepth());
 	}
 
-	return idxstring;
+	// now apply label width string to every par
+	// in sequence
+	depth_type const depth = c.paragraph().getDepth();
+	Layout const & layout = c.paragraph().layout();
+	for ( ; c.pit() <= c.lastpit() ; ++c.pit()) {
+		while (c.paragraph().getDepth() > depth) {
+			++c.pit();
+			if (c.pit() > c.lastpit())
+				return;
+		}
+		if (c.paragraph().getDepth() < depth)
+			return;
+		if (c.paragraph().layout() != layout)
+			return;
+		c.recordUndo();
+		c.paragraph().setLabelWidthString(s);
+	}
 }
 
 
-void Text::setParagraphs(Cursor & cur, docstring arg, bool merge) 
+void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
 {
-	BOOST_ASSERT(cur.text());
-	// make sure that the depth behind the selection are restored, too
-	pit_type undopit = undoSpan(cur.selEnd().pit());
-	recUndo(cur, cur.selBegin().pit(), undopit - 1);
+	LBUFERR(cur.text());
 
-	for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
-	     pit <= end; ++pit) {
-		Paragraph & par = pars_[pit];
+	//FIXME UNICODE
+	string const argument = to_utf8(arg);
+	depth_type priordepth = -1;
+	Layout priorlayout;
+	Cursor c(cur.bv());
+	c.setCursor(cur.selectionBegin());
+	for ( ; c <= cur.selectionEnd() ; ++c.pit()) {
+		Paragraph & par = c.paragraph();
 		ParagraphParameters params = par.params();
-		params.read(to_utf8(arg), merge);
-		Layout const & layout = *(par.layout());
-		par.params().apply(params, layout);
+		params.read(argument, merge);
+		// Changes to label width string apply to all paragraphs
+		// with same layout in a sequence.
+		// Do this only once for a selected range of paragraphs
+		// of the same layout and depth.
+		c.recordUndo();
+		par.params().apply(params, par.layout());
+		if (par.getDepth() != priordepth || par.layout() != priorlayout)
+			setLabelWidthStringToSequence(c, params.labelWidthString());
+		priordepth = par.getDepth();
+		priorlayout = par.layout();
 	}
 }
 
 
-//FIXME This is a little redundant now, but it's probably worth keeping,
-//especially if we're going to go away from using serialization internally
-//quite so much.
-void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p) 
-{
-	BOOST_ASSERT(cur.text());
-	// make sure that the depth behind the selection are restored, too
-	pit_type undopit = undoSpan(cur.selEnd().pit());
-	recUndo(cur, cur.selBegin().pit(), undopit - 1);
-
-	for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
-	     pit <= end; ++pit) {
-		Paragraph & par = pars_[pit];
-		Layout const & layout = *(par.layout());
-		par.params().apply(p, layout);
-	}	
+void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
+{
+	LBUFERR(cur.text());
+
+	depth_type priordepth = -1;
+	Layout priorlayout;
+	Cursor c(cur.bv());
+	c.setCursor(cur.selectionBegin());
+	for ( ; c < cur.selectionEnd() ; ++c.pit()) {
+		Paragraph & par = c.paragraph();
+		// Changes to label width string apply to all paragraphs
+		// with same layout in a sequence.
+		// Do this only once for a selected range of paragraphs
+		// of the same layout and depth.
+		cur.recordUndo();
+		par.params().apply(p, par.layout());
+		if (par.getDepth() != priordepth || par.layout() != priorlayout)
+			setLabelWidthStringToSequence(c,
+				par.params().labelWidthString());
+		priordepth = par.getDepth();
+		priorlayout = par.layout();
+	}
 }
 
 
 // this really should just insert the inset and not move the cursor.
 void Text::insertInset(Cursor & cur, Inset * inset)
 {
-	BOOST_ASSERT(this == cur.text());
-	BOOST_ASSERT(inset);
+	LBUFERR(this == cur.text());
+	LBUFERR(inset);
 	cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
-				    Change(cur.buffer().params().trackChanges ?
-					   Change::INSERTED : Change::UNCHANGED));
-}
-
-
-// needed to insert the selection
-void Text::insertStringAsLines(Cursor & cur, docstring const & str)
-{
-	cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
-					 cur.current_font, str, autoBreakRows_);
-}
-
-
-// turn double CR to single CR, others are converted into one
-// blank. Then insertStringAsLines is called
-void Text::insertStringAsParagraphs(Cursor & cur, docstring const & str)
-{
-	docstring linestr = str;
-	bool newline_inserted = false;
-
-	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
-				// insertStringAsLines. Of course, it is a dirty
-				// trick, but it works...
-				linestr[i - 1] = '\r';
-				linestr[i] = '\n';
-			} else {
-				linestr[i] = ' ';
-				newline_inserted = true;
-			}
-		} else if (isPrintable(linestr[i])) {
-			newline_inserted = false;
-		}
-	}
-	insertStringAsLines(cur, linestr);
+		Change(cur.buffer()->params().track_changes
+		? Change::INSERTED : Change::UNCHANGED));
 }
 
 
-bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
+bool Text::setCursor(Cursor & cur, pit_type pit, pos_type pos,
 			bool setfont, bool boundary)
 {
+	TextMetrics const & tm = cur.bv().textMetrics(this);
+	bool const update_needed = !tm.contains(pit);
 	Cursor old = cur;
-	setCursorIntern(cur, par, pos, setfont, boundary);
-	return cur.bv().checkDepm(cur, old);
+	setCursorIntern(cur, pit, pos, setfont, boundary);
+	return cur.bv().checkDepm(cur, old) || update_needed;
 }
 
 
-void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
+void Text::setCursorIntern(Cursor & cur, pit_type pit, pos_type pos,
+                           bool setfont, bool boundary)
 {
-	BOOST_ASSERT(par != int(paragraphs().size()));
-	cur.pit() = par;
-	cur.pos() = pos;
-
-	// now some strict checking
-	Paragraph & para = getPar(par);
-
-	// None of these should happen, but we're scaredy-cats
-	if (pos < 0) {
-		lyxerr << "dont like -1" << endl;
-		BOOST_ASSERT(false);
-	}
-
-	if (pos > para.size()) {
-		lyxerr << "dont like 1, pos: " << pos
-		       << " size: " << para.size()
-		       << " par: " << par << endl;
-		BOOST_ASSERT(false);
-	}
-}
-
-
-void Text::setCursorIntern(Cursor & cur,
-			      pit_type par, pos_type pos, bool setfont, bool boundary)
-{
-	BOOST_ASSERT(this == cur.text());
+	LBUFERR(this == cur.text());
 	cur.boundary(boundary);
-	setCursor(cur.top(), par, pos);
+	cur.top().setPitPos(pit, pos);
 	if (setfont)
 		cur.setCurrentFont();
 }
@@ -576,14 +571,14 @@ void Text::setCursorIntern(Cursor & cur,
 
 bool Text::checkAndActivateInset(Cursor & cur, bool front)
 {
-	if (cur.selection())
-		return false;
 	if (front && cur.pos() == cur.lastpos())
 		return false;
 	if (!front && cur.pos() == 0)
 		return false;
 	Inset * inset = front ? cur.nextInset() : cur.prevInset();
-	if (!isHighlyEditableInset(inset))
+	if (!inset || !inset->editable())
+		return false;
+	if (cur.selection() && cur.realAnchor().find(inset) == -1)
 		return false;
 	/*
 	 * Apparently, when entering an inset we are expected to be positioned
@@ -595,14 +590,34 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
 	if (!front)
 		--cur.pos();
 	inset->edit(cur, front);
+	cur.setCurrentFont();
 	return true;
 }
 
 
-bool Text::cursorLeft(Cursor & cur)
+bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool movingLeft)
+{
+	if (cur.pos() == -1)
+		return false;
+	if (cur.pos() == cur.lastpos())
+		return false;
+	Paragraph & par = cur.paragraph();
+	Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
+	if (!inset || !inset->editable())
+		return false;
+	if (cur.selection() && cur.realAnchor().find(inset) == -1)
+		return false;
+	inset->edit(cur, movingForward, 
+		movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
+	cur.setCurrentFont();
+	return true;
+}
+
+
+bool Text::cursorBackward(Cursor & cur)
 {
 	// Tell BufferView to test for FitCursor in any case!
-	cur.updateFlags(Update::FitCursor);
+	cur.screenUpdateFlags(Update::FitCursor);
 
 	// not at paragraph start?
 	if (cur.pos() > 0) {
@@ -622,6 +637,7 @@ bool Text::cursorLeft(Cursor & cur)
 				cur.textRow().pos() == cur.pos() &&
 				!cur.paragraph().isLineSeparator(cur.pos() - 1) &&
 				!cur.paragraph().isNewline(cur.pos() - 1) &&
+				!cur.paragraph().isEnvSeparator(cur.pos() - 1) &&
 				!cur.paragraph().isSeparator(cur.pos() - 1)) {
 			return setCursor(cur, cur.pit(), cur.pos(), true, true);
 		}
@@ -635,16 +651,48 @@ bool Text::cursorLeft(Cursor & cur)
 	}
 
 	// move to the previous paragraph or do nothing
-	if (cur.pit() > 0)
-		return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
+	if (cur.pit() > 0) {
+		Paragraph & par = getPar(cur.pit() - 1);
+		pos_type lastpos = par.size();
+		if (lastpos > 0 && par.isEnvSeparator(lastpos - 1))
+			return setCursor(cur, cur.pit() - 1, lastpos - 1, true, false);
+		else
+			return setCursor(cur, cur.pit() - 1, lastpos, true, false);
+	}
 	return false;
 }
 
 
-bool Text::cursorRight(Cursor & cur)
+bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
+{
+	Cursor temp_cur = cur;
+	temp_cur.posVisLeft(skip_inset);
+	if (temp_cur.depth() > cur.depth()) {
+		cur = temp_cur;
+		return false;
+	}
+	return setCursor(cur, temp_cur.pit(), temp_cur.pos(), 
+		true, temp_cur.boundary());
+}
+
+
+bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
+{
+	Cursor temp_cur = cur;
+	temp_cur.posVisRight(skip_inset);
+	if (temp_cur.depth() > cur.depth()) {
+		cur = temp_cur;
+		return false;
+	}
+	return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+		true, temp_cur.boundary());
+}
+
+
+bool Text::cursorForward(Cursor & cur)
 {
 	// Tell BufferView to test for FitCursor in any case!
-	cur.updateFlags(Update::FitCursor);
+	cur.screenUpdateFlags(Update::FitCursor);
 
 	// not at paragraph end?
 	if (cur.pos() != cur.lastpos()) {
@@ -674,12 +722,19 @@ bool Text::cursorRight(Cursor & cur)
 			bool sep2 = cur.paragraph().isSeparator(cur.pos()+1);
 		}
 #endif
-		if (cur.textRow().endpos() == cur.pos() + 1 &&
-		    cur.textRow().endpos() != cur.lastpos() &&
-				!cur.paragraph().isNewline(cur.pos()) &&
-				!cur.paragraph().isLineSeparator(cur.pos()) &&
-				!cur.paragraph().isSeparator(cur.pos())) {
-			return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+		if (cur.textRow().endpos() == cur.pos() + 1) {
+			if (cur.paragraph().isEnvSeparator(cur.pos()) &&
+			    cur.pos() + 1 == cur.lastpos() &&
+			    cur.pit() != cur.lastpit()) {
+				// move to next paragraph
+				return setCursor(cur, cur.pit() + 1, 0, true, false);
+			} else if (cur.textRow().endpos() != cur.lastpos() &&
+				   !cur.paragraph().isNewline(cur.pos()) &&
+				   !cur.paragraph().isEnvSeparator(cur.pos()) &&
+				   !cur.paragraph().isLineSeparator(cur.pos()) &&
+				   !cur.paragraph().isSeparator(cur.pos())) {
+				return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+			}
 		}
 		
 		// in front of RTL boundary? Stay on this side of the boundary because:
@@ -693,7 +748,7 @@ bool Text::cursorRight(Cursor & cur)
 
 	// move to next paragraph
 	if (cur.pit() != cur.lastpit())
-		return setCursor(cur, cur.pit() + 1, 0);
+		return setCursor(cur, cur.pit() + 1, 0, true, false);
 	return false;
 }
 
@@ -713,7 +768,13 @@ bool Text::cursorDownParagraph(Cursor & cur)
 {
 	bool updated = false;
 	if (cur.pit() != cur.lastpit())
-		updated = setCursor(cur, cur.pit() + 1, 0);
+		if (lyxrc.mac_like_cursor_movement)
+			if (cur.pos() == cur.lastpos())
+				updated = setCursor(cur, cur.pit() + 1, getPar(cur.pit() + 1).size());
+			else
+				updated = setCursor(cur, cur.pit(), cur.lastpos());
+		else
+			updated = setCursor(cur, cur.pit() + 1, 0);
 	else
 		updated = setCursor(cur, cur.pit(), cur.lastpos());
 	return updated;
@@ -725,7 +786,7 @@ bool Text::cursorDownParagraph(Cursor & cur)
 void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
 {
 	// Do nothing if cursor is not in the paragraph where the
-	// deletion occured,
+	// deletion occurred,
 	if (cur.pit() != where.pit())
 		return;
 
@@ -743,7 +804,7 @@ void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
 bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 		Cursor & old, bool & need_anchor_change)
 {
-	//LYXERR(Debug::DEBUG) << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+	//LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
 
 	Paragraph & oldpar = old.paragraph();
 
@@ -768,10 +829,18 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 	// delete the LineSeparator.
 	// MISSING
 
-	bool const same_inset = &old.inset() == &cur.inset();
-	bool const same_par = same_inset && old.pit() == cur.pit();
-	bool const same_par_pos = same_par && old.pos() == cur.pos();
+	// Find a common inset and the corresponding depth.
+	size_t depth = 0;
+	for (; depth < cur.depth(); ++depth)
+		if (&old.inset() == &cur[depth].inset())
+			break;
 
+	// Whether a common inset is found and whether the cursor is still in 
+	// the same paragraph (possibly nested).
+	bool const same_par = depth < cur.depth() && old.pit() == cur[depth].pit();
+	bool const same_par_pos = depth == cur.depth() - 1 && same_par 
+		&& old.pos() == cur[depth].pos();
+	
 	// If the chars around the old cursor were spaces, delete one of them.
 	if (!same_par_pos) {
 		// Only if the cursor has really moved.
@@ -781,14 +850,14 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 		    && oldpar.isLineSeparator(old.pos() - 1)
 		    && !oldpar.isDeleted(old.pos() - 1)
 		    && !oldpar.isDeleted(old.pos())) {
-			oldpar.eraseChar(old.pos() - 1, cur.buffer().params().trackChanges);
+			oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().track_changes);
 // FIXME: 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 CursorSlice code. (JMarc 26/09/2001)
 			// correct all cursor parts
 			if (same_par) {
-				fixCursorAfterDelete(cur.top(), old.top());
+				fixCursorAfterDelete(cur[depth], old.top());
 				need_anchor_change = true;
 			}
 			return true;
@@ -809,11 +878,14 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 
 	if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
 		// Delete old par.
-		recordUndo(old, Undo::ATOMIC,
-			   max(old.pit() - 1, pit_type(0)),
-			   min(old.pit() + 1, old.lastpit()));
+		old.recordUndo(max(old.pit() - 1, pit_type(0)),
+		               min(old.pit() + 1, old.lastpit()));
 		ParagraphList & plist = old.text()->paragraphs();
-		plist.erase(boost::next(plist.begin(), old.pit()));
+		bool const soa = oldpar.params().startOfAppendix();
+		plist.erase(lyx::next(plist.begin(), old.pit()));
+		// do not lose start of appendix marker (bug 4212)
+		if (soa && old.pit() < pit_type(plist.size()))
+			plist[old.pit()].params().startOfAppendix(true);
 
 		// see #warning (FIXME?) above 
 		if (cur.depth() >= old.depth()) {
@@ -832,7 +904,7 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 		return true;
 	}
 
-	if (oldpar.stripLeadingSpaces(cur.buffer().params().trackChanges)) {
+	if (oldpar.stripLeadingSpaces(cur.buffer()->params().track_changes)) {
 		need_anchor_change = true;
 		// We return true here because the Paragraph contents changed and
 		// we need a redraw before further action is processed.
@@ -845,7 +917,7 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 
 void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
 {
-	BOOST_ASSERT(first >= 0 && first <= last && last < (int) pars_.size());
+	LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), return);
 
 	for (pit_type pit = first; pit <= last; ++pit) {
 		Paragraph & par = pars_[pit];
@@ -863,8 +935,9 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 			}
 		}
 
-		// don't delete anything if this is the only remaining paragraph within the given range
-		// note: Text::acceptOrRejectChanges() sets the cursor to 'first' after calling DEPM
+		// don't delete anything if this is the only remaining paragraph
+		// within the given range. Note: Text::acceptOrRejectChanges()
+		// sets the cursor to 'first' after calling DEPM
 		if (first == last)
 			continue;
 
@@ -873,7 +946,7 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 			continue;
 
 		if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {
-			pars_.erase(boost::next(pars_.begin(), pit));
+			pars_.erase(lyx::next(pars_.begin(), pit));
 			--pit;
 			--last;
 			continue;
@@ -884,15 +957,4 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 }
 
 
-void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
-{
-	recordUndo(cur, Undo::ATOMIC, first, last);
-}
-
-
-void Text::recUndo(Cursor & cur, pit_type par) const
-{
-	recordUndo(cur, Undo::ATOMIC, par, par);
-}
-
 } // namespace lyx