X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText.cpp;h=c9bb7e3b563c5e0af33fdfab50455511c0b455ab;hb=cfbe5dd9e1da55cba9499bee0220c2fdab65c3c0;hp=1b9ca70d04ad19f09cb671f28d00b39de9686feb;hpb=cd4c58fb92374c116e4d5d700a500aca8bd34771;p=lyx.git

diff --git a/src/Text.cpp b/src/Text.cpp
index 1b9ca70d04..c9bb7e3b56 100644
--- a/src/Text.cpp
+++ b/src/Text.cpp
@@ -1,5 +1,5 @@
 /**
- * \file src/text.cpp
+ * \file src/Text.cpp
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
@@ -26,17 +26,14 @@
 #include "BufferParams.h"
 #include "BufferView.h"
 #include "Changes.h"
+#include "CompletionList.h"
 #include "Cursor.h"
-#include "ParIterator.h"
 #include "CutAndPaste.h"
-#include "debug.h"
 #include "DispatchResult.h"
 #include "Encoding.h"
 #include "ErrorList.h"
 #include "FuncRequest.h"
 #include "factory.h"
-#include "FontIterator.h"
-#include "gettext.h"
 #include "Language.h"
 #include "Length.h"
 #include "Lexer.h"
@@ -44,55 +41,44 @@
 #include "Paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
+#include "ParIterator.h"
+#include "TextClass.h"
 #include "TextMetrics.h"
 #include "VSpace.h"
 #include "WordLangTuple.h"
-
-#include "frontends/FontMetrics.h"
-#include "frontends/Painter.h"
+#include "WordList.h"
 
 #include "insets/InsetText.h"
 #include "insets/InsetBibitem.h"
 #include "insets/InsetCaption.h"
-#include "insets/InsetHFill.h"
 #include "insets/InsetLine.h"
 #include "insets/InsetNewline.h"
-#include "insets/InsetPagebreak.h"
+#include "insets/InsetNewpage.h"
 #include "insets/InsetOptArg.h"
 #include "insets/InsetSpace.h"
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetTabular.h"
 
+#include "support/lassert.h"
+#include "support/convert.h"
+#include "support/debug.h"
 #include "support/docstream.h"
+#include "support/gettext.h"
 #include "support/lstrings.h"
 #include "support/textutils.h"
-#include "support/convert.h"
 
-#include <boost/current_function.hpp>
 #include <boost/next_prior.hpp>
 
 #include <sstream>
 
-using std::auto_ptr;
-using std::advance;
-using std::distance;
-using std::max;
-using std::min;
-using std::endl;
-using std::string;
+using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 
-using support::bformat;
-using support::contains;
-using support::rsplit;
-using support::split;
-
 using cap::cutSelection;
 using cap::pasteParagraphList;
 
-using frontend::FontMetrics;
-
 namespace {
 
 void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
@@ -111,10 +97,22 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
 		font = Font(inherit_font, bp.language);
 		change = Change(Change::UNCHANGED);
 
-		TextClass const & tclass = bp.getTextClass();
+		DocumentClass const & tclass = bp.documentClass();
 
-		if (layoutname.empty()) {
+		if (layoutname.empty())
 			layoutname = tclass.defaultLayoutName();
+
+		if (par.forceEmptyLayout()) {
+			// in this case only the empty layout is allowed
+			layoutname = tclass.emptyLayoutName();
+		} else if (par.useEmptyLayout()) {
+			// in this case, default layout maps to empty layout 
+			if (layoutname == tclass.defaultLayoutName())
+				layoutname = tclass.emptyLayoutName();
+		} else { 
+			// otherwise, the empty layout maps to the default
+			if (layoutname == tclass.emptyLayoutName())
+				layoutname = tclass.defaultLayoutName();
 		}
 
 		bool hasLayout = tclass.hasLayout(layoutname);
@@ -123,28 +121,26 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
 			errorList.push_back(ErrorItem(_("Unknown layout"),
 			bformat(_("Layout '%1$s' does not exist in textclass '%2$s'\nTrying to use the default instead.\n"),
 			layoutname, from_utf8(tclass.name())), par.id(), 0, par.size()));
-			layoutname = tclass.defaultLayoutName();
+			layoutname = par.useEmptyLayout() ? 
+					tclass.emptyLayoutName() :
+					tclass.defaultLayoutName();
 		}
 
-		par.layout(bp.getTextClass()[layoutname]);
+		par.setLayout(bp.documentClass()[layoutname]);
 
 		// Test whether the layout is obsolete.
-		LayoutPtr const & layout = par.layout();
-		if (!layout->obsoleted_by().empty())
-			par.layout(bp.getTextClass()[layout->obsoleted_by()]);
+		Layout const & layout = par.layout();
+		if (!layout.obsoleted_by().empty())
+			par.setLayout(bp.documentClass()[layout.obsoleted_by()]);
 
 		par.params().read(lex);
 
 	} else if (token == "\\end_layout") {
-		lyxerr << BOOST_CURRENT_FUNCTION
-		       << ": Solitary \\end_layout in line "
-		       << lex.getLineNo() << "\n"
-		       << "Missing \\begin_layout?.\n";
+		LYXERR0("Solitary \\end_layout in line " << lex.lineNumber() << "\n"
+		       << "Missing \\begin_layout ?");
 	} else if (token == "\\end_inset") {
-		lyxerr << BOOST_CURRENT_FUNCTION
-		       << ": Solitary \\end_inset in line "
-		       << lex.getLineNo() << "\n"
-		       << "Missing \\begin_inset?.\n";
+		LYXERR0("Solitary \\end_inset in line " << lex.lineNumber() << "\n"
+		       << "Missing \\begin_inset ?");
 	} else if (token == "\\begin_inset") {
 		Inset * inset = readInset(lex, buf);
 		if (inset)
@@ -202,60 +198,27 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
 	} else if (token == "\\color") {
 		lex.next();
 		setLyXColor(lex.getString(), font.fontInfo());
-	} else if (token == "\\InsetSpace" || token == "\\SpecialChar") {
-
-		// Insets don't make sense in a free-spacing context! ---Kayvan
-		if (par.isFreeSpacing()) {
-			if (token == "\\InsetSpace")
-				par.appendChar(' ', font, change);
-			else if (lex.isOK()) {
-				lex.next();
-				string const next_token = lex.getString();
-				if (next_token == "\\-")
-					par.appendChar('-', font, change);
-				else {
-					lex.printError("Token `$$Token' "
-						       "is in free space "
-						       "paragraph layout!");
-				}
-			}
-		} else {
+	} else if (token == "\\SpecialChar") {
 			auto_ptr<Inset> inset;
-			if (token == "\\SpecialChar" )
-				inset.reset(new InsetSpecialChar);
-			else
-				inset.reset(new InsetSpace);
-			inset->read(buf, lex);
+			inset.reset(new InsetSpecialChar);
+			inset->read(lex);
 			par.insertInset(par.size(), inset.release(),
 					font, change);
-		}
 	} else if (token == "\\backslash") {
 		par.appendChar('\\', font, change);
-	} else if (token == "\\newline") {
-		auto_ptr<Inset> inset(new InsetNewline);
-		inset->read(buf, lex);
-		par.insertInset(par.size(), inset.release(), font, change);
 	} else if (token == "\\LyXTable") {
 		auto_ptr<Inset> inset(new InsetTabular(buf));
-		inset->read(buf, lex);
+		inset->read(lex);
 		par.insertInset(par.size(), inset.release(), font, change);
-	} else if (token == "\\hfill") {
-		par.insertInset(par.size(), new InsetHFill, font, change);
 	} else if (token == "\\lyxline") {
 		par.insertInset(par.size(), new InsetLine, font, change);
-	} else if (token == "\\newpage") {
-		par.insertInset(par.size(), new InsetPagebreak, font, change);
-	} else if (token == "\\clearpage") {
-		par.insertInset(par.size(), new InsetClearPage, font, change);
-	} else if (token == "\\cleardoublepage") {
-		par.insertInset(par.size(), new InsetClearDoublePage, font, change);
 	} else if (token == "\\change_unchanged") {
 		change = Change(Change::UNCHANGED);
 	} else if (token == "\\change_inserted") {
 		lex.eatLine();
-		std::istringstream is(lex.getString());
+		istringstream is(lex.getString());
 		unsigned int aid;
-		time_type ct;
+		time_t ct;
 		is >> aid >> ct;
 		if (aid >= bp.author_map.size()) {
 			errorList.push_back(ErrorItem(_("Change tracking error"),
@@ -266,9 +229,9 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
 			change = Change(Change::INSERTED, bp.author_map[aid], ct);
 	} else if (token == "\\change_deleted") {
 		lex.eatLine();
-		std::istringstream is(lex.getString());
+		istringstream is(lex.getString());
 		unsigned int aid;
-		time_type ct;
+		time_t ct;
 		is >> aid >> ct;
 		if (aid >= bp.author_map.size()) {
 			errorList.push_back(ErrorItem(_("Change tracking error"),
@@ -309,14 +272,13 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex,
 			break;
 		}
 
-		LYXERR(Debug::PARSER) << "Handling paragraph token: `"
-				      << token << '\'' << endl;
+		LYXERR(Debug::PARSER, "Handling paragraph token: `" << token << '\'');
 		if (token == "\\begin_layout" || token == "\\end_document"
 		    || token == "\\end_inset" || token == "\\begin_deeper"
 		    || token == "\\end_deeper") {
 			lex.pushToken(token);
 			lyxerr << "Paragraph ended in line "
-			       << lex.getLineNo() << "\n"
+			       << lex.lineNumber() << "\n"
 			       << "Missing \\end_layout.\n";
 			break;
 		}
@@ -331,17 +293,45 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex,
 
 } // namespace anon
 
+class TextCompletionList : public CompletionList
+{
+public:
+	///
+	TextCompletionList(Cursor const & cur)
+	: buf_(cur.buffer()), pos_(0) {}
+	///
+	virtual ~TextCompletionList() {}
+	
+	///
+	virtual bool sorted() const { return true; }
+	///
+	virtual size_t size() const
+	{
+		return theWordList().size();
+	}
+	///
+	virtual docstring const & data(size_t idx) const
+	{
+		return theWordList().word(idx);
+	}
+	
+private:
+	///
+	Buffer const & buf_;
+	///
+	size_t pos_;
+};
+
 
 bool Text::empty() const
 {
 	return pars_.empty() || (pars_.size() == 1 && pars_[0].empty()
 		// FIXME: Should we consider the labeled type as empty too? 
-		&& pars_[0].layout()->labeltype == LABEL_NO_LABEL);
+		&& pars_[0].layout().labeltype == LABEL_NO_LABEL);
 }
 
 
-double Text::spacing(Buffer const & buffer,
-		Paragraph const & par) const
+double Text::spacing(Buffer const & buffer, Paragraph const & par) const
 {
 	if (par.params().spacing().isDefault())
 		return buffer.params().spacing().getValue();
@@ -351,18 +341,18 @@ double Text::spacing(Buffer const & buffer,
 
 void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 
 	Paragraph & cpar = cur.paragraph();
 	pit_type cpit = cur.pit();
 
-	TextClass const & tclass = cur.buffer().params().getTextClass();
-	LayoutPtr const & layout = cpar.layout();
+	DocumentClass const & tclass = cur.buffer().params().documentClass();
+	Layout const & layout = cpar.layout();
 
 	// this is only allowed, if the current paragraph is not empty
 	// or caption and if it has not the keepempty flag active
 	if (cur.lastpos() == 0 && !cpar.allowEmpty() &&
-	    layout->labeltype != LABEL_SENSITIVE)
+	    layout.labeltype != LABEL_SENSITIVE)
 		return;
 
 	// a layout change may affect also the following paragraph
@@ -375,12 +365,12 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 
 	// What should the layout for the new paragraph be?
 	bool keep_layout = inverse_logic ? 
-		!layout->isEnvironment() 
-		: layout->isEnvironment();
+		!layout.isEnvironment() 
+		: layout.isEnvironment();
 
 	// We need to remember this before we break the paragraph, because
 	// that invalidates the layout variable
-	bool sensitive = layout->labeltype == LABEL_SENSITIVE;
+	bool sensitive = layout.labeltype == LABEL_SENSITIVE;
 
 	// we need to set this before we insert the paragraph.
 	bool const isempty = cpar.allowEmpty() && cpar.empty();
@@ -397,9 +387,11 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 	if (sensitive) {
 		if (cur.pos() == 0)
 			// set to standard-layout
+		//FIXME Check if this should be emptyLayout() in some cases
 			pars_[cpit].applyLayout(tclass.defaultLayout());
 		else
 			// set to standard-layout
+			//FIXME Check if this should be emptyLayout() in some cases
 			pars_[next_par].applyLayout(tclass.defaultLayout());
 	}
 
@@ -426,7 +418,7 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 // same Paragraph one to the right and make a rebreak
 void Text::insertChar(Cursor & cur, char_type c)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 
 	cur.recordUndo(INSERT_UNDO);
 
@@ -436,7 +428,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 	// try to remove this
 	pit_type const pit = cur.pit();
 
-	bool const freeSpacing = par.layout()->free_spacing ||
+	bool const freeSpacing = par.layout().free_spacing ||
 		par.isFreeSpacing();
 
 	if (lyxrc.auto_number) {
@@ -449,8 +441,8 @@ void Text::insertChar(Cursor & cur, char_type c)
 			    !(contains(number_seperators, c) &&
 			      cur.pos() != 0 &&
 			      cur.pos() != cur.lastpos() &&
-			      tm.getDisplayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
-			      tm.getDisplayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON)
+			      tm.displayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
+			      tm.displayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON)
 			   )
 				number(cur); // Set current_font.number to OFF
 		} else if (isDigit(c) &&
@@ -468,7 +460,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 						tm.font_);
 				} else if (contains(number_seperators, c)
 				     && cur.pos() >= 2
-				     && tm.getDisplayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
+				     && tm.displayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
 					setCharFont(buffer, pit, cur.pos() - 1, cur.current_font,
 						tm.font_);
 				}
@@ -501,7 +493,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 	if ((cur.pos() >= 2) && (par.isLineSeparator(cur.pos() - 1))) {
 		// get font in front and behind the space in question. But do NOT 
 		// use getFont(cur.pos()) because the character c is not inserted yet
-		Font const pre_space_font  = tm.getDisplayFont(cur.pit(), cur.pos() - 2);
+		Font const pre_space_font  = tm.displayFont(cur.pit(), cur.pos() - 2);
 		Font const & post_space_font = cur.real_current_font;
 		bool pre_space_rtl  = pre_space_font.isVisibleRightToLeft();
 		bool post_space_rtl = post_space_font.isVisibleRightToLeft();
@@ -514,7 +506,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 				(pre_space_rtl == par.isRTL(buffer.params())) ?
 				pre_space_font.language() : post_space_font.language();
 
-			Font space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 1);
+			Font space_font = tm.displayFont(cur.pit(), cur.pos() - 1);
 			space_font.setLanguage(lang);
 			par.setFont(cur.pos() - 1, space_font);
 		}
@@ -538,7 +530,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 			}
 			return;
 		}
-		BOOST_ASSERT(cur.pos() > 0);
+		LASSERT(cur.pos() > 0, /**/);
 		if ((par.isLineSeparator(cur.pos() - 1) || par.isNewline(cur.pos() - 1))
 		    && !par.isDeleted(cur.pos() - 1)) {
 			static bool sent_space_message = false;
@@ -552,7 +544,7 @@ void Text::insertChar(Cursor & cur, char_type c)
 	}
 
 	par.insertChar(cur.pos(), c, cur.current_font, cur.buffer().params().trackChanges);
-	checkBufferStructure(cur.buffer(), cur);
+	cur.checkBufferStructure();
 
 //		cur.updateFlags(Update::Force);
 	setCursor(cur.top(), cur.pit(), cur.pos() + 1);
@@ -562,6 +554,8 @@ void Text::insertChar(Cursor & cur, char_type c)
 
 void Text::charInserted(Cursor & cur)
 {
+	Paragraph & par = cur.paragraph();
+
 	// Here we call finishUndo for every 20 characters inserted.
 	// This is from my experience how emacs does it. (Lgb)
 	static unsigned int counter;
@@ -571,6 +565,15 @@ void Text::charInserted(Cursor & cur)
 		cur.finishUndo();
 		counter = 0;
 	}
+
+	// register word if a non-letter was entered
+	if (cur.pos() > 1
+	    && par.isLetter(cur.pos() - 2)
+	    && !par.isLetter(cur.pos() - 1)) {
+		// get the word in front of cursor
+		LASSERT(this == cur.text(), /**/);
+		cur.paragraph().updateWords(cur.top());
+	}
 }
 
 
@@ -579,49 +582,140 @@ void Text::charInserted(Cursor & cur)
 
 bool Text::cursorForwardOneWord(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
+
+	pos_type const lastpos = cur.lastpos();
+	pit_type pit = cur.pit();
+	pos_type pos = cur.pos();
+	Paragraph const & par = cur.paragraph();
 
-	Cursor old = cur;
+	// Skip over either a non-char inset or a full word
+	if (pos != lastpos && !par.isLetter(pos) && !par.isChar(pos))
+		++pos;
+	else while (pos != lastpos && par.isLetter(pos))
+			++pos;
 
-	if (old.pos() == old.lastpos() && old.pit() != old.lastpit()) {
-		++old.pit();
-		old.pos() = 0;
-	} else {
-		// Advance through word.
-		while (old.pos() != old.lastpos() && old.paragraph().isLetter(old.pos()))
-			++old.pos();
-		// Skip through trailing nonword stuff.
-		while (old.pos() != old.lastpos() && !old.paragraph().isLetter(old.pos()))
-			++old.pos();
+	// Skip through trailing punctuation and spaces.
+	while (pos != lastpos && par.isChar(pos))
+		++pos;
+
+	if (pos == lastpos && pit != cur.lastpit()) {
+		++pit;
+		pos = 0;
 	}
-	return setCursor(cur, old.pit(), old.pos());
+
+	return setCursor(cur, pit, pos);
 }
 
 
 bool Text::cursorBackwardOneWord(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 
-	Cursor old = cur;
+	pit_type pit = cur.pit();
+	pos_type pos = cur.pos();
+	Paragraph & par = cur.paragraph();
 
-	if (old.pos() == 0 && old.pit() != 0) {
-		--old.pit();
-		old.pos() = old.lastpos();
-	} else {
-		// Skip through initial nonword stuff.
-		while (old.pos() != 0 && !old.paragraph().isLetter(old.pos() - 1))
-			--old.pos();
-		// Advance through word.
-		while (old.pos() != 0 && old.paragraph().isLetter(old.pos() - 1))
-			--old.pos();
+	// Skip through puctuation and spaces.
+	while (pos != 0 && par.isChar(pos - 1))
+		--pos;
+
+	// Skip over either a non-char inset or a full word
+	if (pos != 0 && !par.isLetter(pos) && !par.isChar(pos - 1))
+		--pos;
+	else while (pos != 0 && par.isLetter(pos - 1))
+			--pos;
+
+	if (pos == 0 && pit != 0) {
+		--pit;
+		pos = getPar(cur.pit() - 1).size();
+	}
+
+	return setCursor(cur, pit, pos);
+}
+
+
+bool Text::cursorVisLeftOneWord(Cursor & cur)
+{
+	LASSERT(this == cur.text(), /**/);
+
+	pos_type left_pos, right_pos;
+	bool left_is_letter, right_is_letter;
+
+	Cursor temp_cur = cur;
+
+	// always try to move at least once...
+	while (temp_cur.posVisLeft(true /* skip_inset */)) {
+
+		// collect some information about current cursor position
+		temp_cur.getSurroundingPos(left_pos, right_pos);
+		left_is_letter = 
+			(left_pos > -1 ? temp_cur.paragraph().isLetter(left_pos) : false);
+		right_is_letter = 
+			(right_pos > -1 ? temp_cur.paragraph().isLetter(right_pos) : false);
+
+		// if we're not at a letter/non-letter boundary, continue moving
+		if (left_is_letter == right_is_letter)
+			continue;
+
+		// we should stop when we have an LTR word on our right or an RTL word
+		// on our left
+		if ((left_is_letter && temp_cur.paragraph().getFontSettings(
+				temp_cur.bv().buffer().params(), 
+				left_pos).isRightToLeft())
+			|| (right_is_letter && !temp_cur.paragraph().getFontSettings(
+				temp_cur.bv().buffer().params(), 
+				right_pos).isRightToLeft()))
+			break;
+	}
+
+	return setCursor(cur, temp_cur.pit(), temp_cur.pos(), 
+					 true, temp_cur.boundary());
+}
+
+
+bool Text::cursorVisRightOneWord(Cursor & cur)
+{
+	LASSERT(this == cur.text(), /**/);
+
+	pos_type left_pos, right_pos;
+	bool left_is_letter, right_is_letter;
+
+	Cursor temp_cur = cur;
+
+	// always try to move at least once...
+	while (temp_cur.posVisRight(true /* skip_inset */)) {
+
+		// collect some information about current cursor position
+		temp_cur.getSurroundingPos(left_pos, right_pos);
+		left_is_letter = 
+			(left_pos > -1 ? temp_cur.paragraph().isLetter(left_pos) : false);
+		right_is_letter = 
+			(right_pos > -1 ? temp_cur.paragraph().isLetter(right_pos) : false);
+
+		// if we're not at a letter/non-letter boundary, continue moving
+		if (left_is_letter == right_is_letter)
+			continue;
+
+		// we should stop when we have an LTR word on our right or an RTL word
+		// on our left
+		if ((left_is_letter && temp_cur.paragraph().getFontSettings(
+				temp_cur.bv().buffer().params(), 
+				left_pos).isRightToLeft())
+			|| (right_is_letter && !temp_cur.paragraph().getFontSettings(
+				temp_cur.bv().buffer().params(), 
+				right_pos).isRightToLeft()))
+			break;
 	}
-	return setCursor(cur, old.pit(), old.pos());
+
+	return setCursor(cur, temp_cur.pit(), temp_cur.pos(), 
+					 true, temp_cur.boundary());
 }
 
 
 void Text::selectWord(Cursor & cur, word_location loc)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	CursorSlice from = cur.top();
 	CursorSlice to = cur.top();
 	getWord(from, to, loc);
@@ -639,7 +733,7 @@ void Text::selectWord(Cursor & cur, word_location loc)
 // selection is currently set
 bool Text::selectWordWhenUnderCursor(Cursor & cur, word_location loc)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	if (cur.selection())
 		return false;
 	selectWord(cur, loc);
@@ -649,7 +743,7 @@ bool Text::selectWordWhenUnderCursor(Cursor & cur, word_location loc)
 
 void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 
 	if (!cur.selection())
 		return;
@@ -795,7 +889,7 @@ void Text::rejectChanges(BufferParams const & bparams)
 
 void Text::deleteWordForward(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	if (cur.lastpos() == 0)
 		cursorForward(cur);
 	else {
@@ -804,14 +898,14 @@ void Text::deleteWordForward(Cursor & cur)
 		cursorForwardOneWord(cur);
 		cur.setSelection();
 		cutSelection(cur, true, false);
-		checkBufferStructure(cur.buffer(), cur);
+		cur.checkBufferStructure();
 	}
 }
 
 
 void Text::deleteWordBackward(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	if (cur.lastpos() == 0)
 		cursorBackward(cur);
 	else {
@@ -820,7 +914,7 @@ void Text::deleteWordBackward(Cursor & cur)
 		cursorBackwardOneWord(cur);
 		cur.setSelection();
 		cutSelection(cur, true, false);
-		checkBufferStructure(cur.buffer(), cur);
+		cur.checkBufferStructure();
 	}
 }
 
@@ -828,13 +922,15 @@ void Text::deleteWordBackward(Cursor & cur)
 // Kill to end of line.
 void Text::changeCase(Cursor & cur, TextCase action)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	CursorSlice from;
 	CursorSlice to;
 
+	bool gotsel = false;
 	if (cur.selection()) {
 		from = cur.selBegin();
 		to = cur.selEnd();
+		gotsel = true;
 	} else {
 		from = cur.top();
 		getWord(from, to, PARTIAL_WORD);
@@ -859,50 +955,56 @@ void Text::changeCase(Cursor & cur, TextCase action)
 	}
 
 	// the selection may have changed due to logically-only deleted chars
-	setCursor(cur, begPit, begPos);
-	cur.resetAnchor();
-	setCursor(cur, endPit, right);
-	cur.setSelection();
+	if (gotsel) {
+		setCursor(cur, begPit, begPos);
+		cur.resetAnchor();
+		setCursor(cur, endPit, right);
+		cur.setSelection();
+	} else
+		setCursor(cur, endPit, right);
 
-	checkBufferStructure(cur.buffer(), cur);
+	cur.checkBufferStructure();
 }
 
 
 bool Text::handleBibitems(Cursor & cur)
 {
-	if (cur.paragraph().layout()->labeltype != LABEL_BIBLIO)
+	if (cur.paragraph().layout().labeltype != LABEL_BIBLIO)
+		return false;
+
+	if (cur.pos() != 0)
 		return false;
+
+	BufferParams const & bufparams = cur.buffer().params();
+	Paragraph const & par = cur.paragraph();
+	Cursor prevcur = cur;
+	if (cur.pit() > 0) {
+		--prevcur.pit();
+		prevcur.pos() = prevcur.lastpos();
+	}
+	Paragraph const & prevpar = prevcur.paragraph();
+
 	// if a bibitem is deleted, merge with previous paragraph
 	// if this is a bibliography item as well
-	if (cur.pos() == 0) {
-		BufferParams const & bufparams = cur.buffer().params();
-		Paragraph const & par = cur.paragraph();
-		Cursor prevcur = cur;
-		if (cur.pit() > 0) {
-			--prevcur.pit();
-			prevcur.pos() = prevcur.lastpos();
-		}
-		Paragraph const & prevpar = prevcur.paragraph();
-		if (cur.pit() > 0 && par.layout() == prevpar.layout()) {
-			cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
-			mergeParagraph(bufparams, cur.text()->paragraphs(),
-				       prevcur.pit());
-			updateLabels(cur.buffer());
-			setCursorIntern(cur, prevcur.pit(), prevcur.pos());
-			cur.updateFlags(Update::Force);
-		// if not, reset the paragraph to default
-		} else
-			cur.paragraph().layout(
-				bufparams.getTextClass().defaultLayout());
+	if (cur.pit() > 0 && par.layout() == prevpar.layout()) {
+		cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
+		mergeParagraph(bufparams, cur.text()->paragraphs(),
+							prevcur.pit());
+		updateLabels(cur.buffer());
+		setCursorIntern(cur, prevcur.pit(), prevcur.pos());
+		cur.updateFlags(Update::Force);
 		return true;
-	}
-	return false;
+	} 
+
+	// otherwise reset to default
+	cur.paragraph().setEmptyOrDefaultLayout(bufparams.documentClass());
+	return true;
 }
 
 
 bool Text::erase(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	bool needsUpdate = false;
 	Paragraph & par = cur.paragraph();
 
@@ -910,11 +1012,15 @@ bool Text::erase(Cursor & cur)
 		// this is the code for a normal delete, not pasting
 		// any paragraphs
 		cur.recordUndo(DELETE_UNDO);
-		if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges)) {
+		bool const was_inset = cur.paragraph().isInset(cur.pos());
+		if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges))
 			// the character has been logically deleted only => skip it
 			cur.top().forwardPos();
-		}
-		checkBufferStructure(cur.buffer(), cur);
+
+		if (was_inset)
+			updateLabels(cur.buffer());
+		else
+			cur.checkBufferStructure();
 		needsUpdate = true;
 	} else {
 		if (cur.pit() == cur.lastpit())
@@ -936,7 +1042,7 @@ bool Text::erase(Cursor & cur)
 		// Make sure the cursor is correct. Is this really needed?
 		// No, not really... at least not here!
 		cur.text()->setCursor(cur.top(), cur.pit(), cur.pos());
-		checkBufferStructure(cur.buffer(), cur);
+		cur.checkBufferStructure();
 	}
 
 	return needsUpdate;
@@ -945,14 +1051,14 @@ bool Text::erase(Cursor & cur)
 
 bool Text::backspacePos0(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	if (cur.pit() == 0)
 		return false;
 
 	bool needsUpdate = false;
 
 	BufferParams const & bufparams = cur.buffer().params();
-	TextClass const & tclass = bufparams.getTextClass();
+	DocumentClass const & tclass = bufparams.documentClass();
 	ParagraphList & plist = cur.text()->paragraphs();
 	Paragraph const & par = cur.paragraph();
 	Cursor prevcur = cur;
@@ -978,8 +1084,10 @@ bool Text::backspacePos0(Cursor & cur)
 	// layouts. I think it is a real bug of all other
 	// word processors to allow it. It confuses the user.
 	// Correction: Pasting is always allowed with standard-layout
+	// or the empty layout.
 	else if (par.layout() == prevpar.layout()
-		 || par.layout() == tclass.defaultLayout()) {
+		 || tclass.isDefaultLayout(par.layout())
+		 || tclass.isEmptyLayout(par.layout())) {
 		cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
 		mergeParagraph(bufparams, plist, prevcur.pit());
 		needsUpdate = true;
@@ -996,7 +1104,7 @@ bool Text::backspacePos0(Cursor & cur)
 
 bool Text::backspace(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	bool needsUpdate = false;
 	if (cur.pos() == 0) {
 		if (cur.pit() == 0)
@@ -1023,8 +1131,12 @@ bool Text::backspace(Cursor & cur)
 		// without the dreaded mechanism. (JMarc)
 		setCursorIntern(cur, cur.pit(), cur.pos() - 1,
 				false, cur.boundary());
+		bool const was_inset = cur.paragraph().isInset(cur.pos());
 		cur.paragraph().eraseChar(cur.pos(), cur.buffer().params().trackChanges);
-		checkBufferStructure(cur.buffer(), cur);
+		if (was_inset)
+			updateLabels(cur.buffer());
+		else
+			cur.checkBufferStructure();
 	}
 
 	if (cur.pos() == cur.lastpos())
@@ -1041,12 +1153,13 @@ bool Text::backspace(Cursor & cur)
 
 
 bool Text::dissolveInset(Cursor & cur) {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 
 	if (isMainText(cur.bv().buffer()) || cur.inset().nargs() != 1)
 		return false;
 
 	cur.recordUndoInset();
+	cur.mark() = false;
 	cur.selHandle(false);
 	// save position
 	pos_type spos = cur.pos();
@@ -1070,11 +1183,11 @@ bool Text::dissolveInset(Cursor & cur) {
 		for (; it != it_end; it++)
 			it->changeLanguage(b.params(), latex_language, b.language());
 
-		pasteParagraphList(cur, plist, b.params().getTextClassPtr(),
+		pasteParagraphList(cur, plist, b.params().documentClassPtr(),
 				   b.errorList("Paste"));
 		// restore position
-		cur.pit() = std::min(cur.lastpit(), spit);
-		cur.pos() = std::min(cur.lastpos(), spos);
+		cur.pit() = min(cur.lastpit(), spit);
+		cur.pos() = min(cur.lastpos(), spos);
 	}
 	cur.clearSelection();
 	cur.resetAnchor();
@@ -1083,7 +1196,7 @@ bool Text::dissolveInset(Cursor & cur) {
 
 
 void Text::getWord(CursorSlice & from, CursorSlice & to,
-	word_location const loc)
+	word_location const loc) const
 {
 	Paragraph const & from_par = pars_[from.pit()];
 	switch (loc) {
@@ -1108,27 +1221,26 @@ void Text::getWord(CursorSlice & from, CursorSlice & to,
 			--from.pos();
 		break;
 	case NEXT_WORD:
-		lyxerr << "Text::getWord: NEXT_WORD not implemented yet"
-		       << endl;
+		LYXERR0("Text::getWord: NEXT_WORD not implemented yet");
 		break;
 	case PARTIAL_WORD:
 		// no need to move the 'from' cursor
 		break;
 	}
 	to = from;
-	Paragraph & to_par = pars_[to.pit()];
+	Paragraph const & to_par = pars_[to.pit()];
 	while (to.pos() < to_par.size() && to_par.isLetter(to.pos()))
 		++to.pos();
 }
 
 
-void Text::write(Buffer const & buf, std::ostream & os) const
+void Text::write(Buffer const & buf, ostream & os) const
 {
 	ParagraphList::const_iterator pit = paragraphs().begin();
 	ParagraphList::const_iterator end = paragraphs().end();
 	depth_type dth = 0;
 	for (; pit != end; ++pit)
-		pit->write(buf, os, buf.params(), dth);
+		pit->write(os, buf.params(), dth);
 
 	// Close begin_deeper
 	for(; dth > 0; --dth)
@@ -1136,7 +1248,8 @@ void Text::write(Buffer const & buf, std::ostream & os) const
 }
 
 
-bool Text::read(Buffer const & buf, Lexer & lex, ErrorList & errorList)
+bool Text::read(Buffer const & buf, Lexer & lex, 
+		ErrorList & errorList, InsetText * insetPtr)
 {
 	depth_type depth = 0;
 
@@ -1165,23 +1278,26 @@ bool Text::read(Buffer const & buf, Lexer & lex, ErrorList & errorList)
 			Paragraph par;
 			par.params().depth(depth);
 			par.setFont(0, Font(inherit_font, buf.params().language));
+			par.setInsetOwner(insetPtr);
 			pars_.push_back(par);
 
 			// FIXME: goddamn InsetTabular makes us pass a Buffer
 			// not BufferParams
 			lyx::readParagraph(buf, pars_.back(), lex, errorList);
 
+			// register the words in the global word list
+			CursorSlice sl = CursorSlice(*insetPtr);
+			sl.pit() = pars_.size() - 1;
+			pars_.back().updateWords(sl);
 		} else if (token == "\\begin_deeper") {
 			++depth;
 		} else if (token == "\\end_deeper") {
-			if (!depth) {
+			if (!depth)
 				lex.printError("\\end_deeper: " "depth is already null");
-			} else {
+			else
 				--depth;
-			}
 		} else {
-			lyxerr << "Handling unknown body token: `"
-			       << token << '\'' << endl;
+			LYXERR0("Handling unknown body token: `" << token << '\'');
 		}
 	}
 	return true;
@@ -1190,7 +1306,7 @@ bool Text::read(Buffer const & buf, Lexer & lex, ErrorList & errorList)
 // Returns the current font and depth as a message.
 docstring Text::currentState(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	Buffer & buf = cur.buffer();
 	Paragraph const & par = cur.paragraph();
 	odocstringstream os;
@@ -1257,7 +1373,7 @@ docstring Text::currentState(Cursor & cur)
 	if (!par.empty() && cur.pos() < par.size()) {
 		// Force output of code point, not character
 		size_t const c = par.getChar(cur.pos());
-		os << _(", Char: 0x") << std::hex << c;
+		os << _(", Char: 0x") << hex << c;
 	}
 	os << _(", Boundary: ") << cur.boundary();
 //	Row & row = cur.textRow();
@@ -1271,14 +1387,13 @@ docstring Text::getPossibleLabel(Cursor & cur) const
 {
 	pit_type pit = cur.pit();
 
-	LayoutPtr layout = pars_[pit].layout();
+	Layout const * layout = &(pars_[pit].layout());
 
 	docstring text;
-	docstring par_text = pars_[pit].asString(cur.buffer(), false);
+	docstring par_text = pars_[pit].asString();
 	string piece;
 	// the return string of math matrices might contain linebreaks
-	// FIXME: unicode
-	par_text = from_utf8(rsplit(to_utf8(par_text), piece, '\n'));
+	par_text = subst(par_text, '\n', '-');
 	for (int i = 0; i < lyxrc.label_init_length; ++i) {
 		if (par_text.empty())
 			break;
@@ -1299,7 +1414,7 @@ docstring Text::getPossibleLabel(Cursor & cur) const
 
 	// For section, subsection, etc...
 	if (layout->latextype == LATEX_PARAGRAPH && pit != 0) {
-		LayoutPtr const & layout2 = pars_[pit - 1].layout();
+		Layout const * layout2 = &(pars_[pit - 1].layout());
 		if (layout2->latextype != LATEX_PARAGRAPH) {
 			--pit;
 			layout = layout2;
@@ -1347,7 +1462,7 @@ docstring Text::getPossibleLabel(Cursor & cur) const
 
 void Text::charsTranspose(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 
 	pos_type pos = cur.pos();
 
@@ -1396,7 +1511,7 @@ void Text::charsTranspose(Cursor & cur)
 	par.insertChar(pos1, char2, font2, trackChanges);
 	par.insertChar(pos2, char1, font1, trackChanges);
 
-	checkBufferStructure(cur.buffer(), cur);
+	cur.checkBufferStructure();
 
 	// After the transposition, move cursor to after the transposition.
 	setCursor(cur, cur.pit(), pos2);
@@ -1404,4 +1519,60 @@ void Text::charsTranspose(Cursor & cur)
 }
 
 
+DocIterator Text::macrocontextPosition() const
+{
+	return macrocontext_position_;
+}
+
+
+void Text::setMacrocontextPosition(DocIterator const & pos)
+{
+	macrocontext_position_ = pos;
+}
+
+
+docstring Text::previousWord(CursorSlice const & sl) const
+{
+	CursorSlice from = sl;
+	CursorSlice to = sl;
+	getWord(from, to, PREVIOUS_WORD);
+	if (sl == from || to == from)
+		return docstring();
+	
+	Paragraph const & par = sl.paragraph();
+	return par.asString(from.pos(), to.pos());
+}
+
+
+bool Text::completionSupported(Cursor const & cur) const
+{
+	Paragraph const & par = cur.paragraph();
+	return cur.pos() > 0
+		&& (cur.pos() >= par.size() || !par.isLetter(cur.pos()))
+		&& par.isLetter(cur.pos() - 1);
+}
+
+
+CompletionList const * Text::createCompletionList(Cursor const & cur) const
+{
+	return new TextCompletionList(cur);
+}
+
+
+bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/)
+{	
+	LASSERT(cur.bv().cursor() == cur, /**/);
+	cur.insert(s);
+	cur.bv().cursor() = cur;
+	if (!(cur.disp_.update() & Update::Force))
+		cur.updateFlags(cur.disp_.update() | Update::SinglePar);
+	return true;
+}
+	
+	
+docstring Text::completionPrefix(Cursor const & cur) const
+{
+	return previousWord(cur.top());
+}
+
 } // namespace lyx