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

diff --git a/src/Text.cpp b/src/Text.cpp
index 2a7942a607..c9bb7e3b56 100644
--- a/src/Text.cpp
+++ b/src/Text.cpp
@@ -26,15 +26,14 @@
 #include "BufferParams.h"
 #include "BufferView.h"
 #include "Changes.h"
+#include "CompletionList.h"
 #include "Cursor.h"
-#include "ParIterator.h"
 #include "CutAndPaste.h"
 #include "DispatchResult.h"
 #include "Encoding.h"
 #include "ErrorList.h"
 #include "FuncRequest.h"
 #include "factory.h"
-#include "FontIterator.h"
 #include "Language.h"
 #include "Length.h"
 #include "Lexer.h"
@@ -42,15 +41,16 @@
 #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 "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/InsetNewpage.h"
@@ -59,6 +59,7 @@
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetTabular.h"
 
+#include "support/lassert.h"
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
@@ -128,17 +129,17 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
 		par.setLayout(bp.documentClass()[layoutname]);
 
 		// Test whether the layout is obsolete.
-		LayoutPtr const & layout = par.layout();
-		if (!layout->obsoleted_by().empty())
-			par.setLayout(bp.documentClass()[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") {
-		LYXERR0("Solitary \\end_layout in line " << lex.getLineNo() << "\n"
+		LYXERR0("Solitary \\end_layout in line " << lex.lineNumber() << "\n"
 		       << "Missing \\begin_layout ?");
 	} else if (token == "\\end_inset") {
-		LYXERR0("Solitary \\end_inset in line " << lex.getLineNo() << "\n"
+		LYXERR0("Solitary \\end_inset in line " << lex.lineNumber() << "\n"
 		       << "Missing \\begin_inset ?");
 	} else if (token == "\\begin_inset") {
 		Inset * inset = readInset(lex, buf);
@@ -197,59 +198,20 @@ 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.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 == "\\linebreak") {
-		auto_ptr<Inset> inset(new InsetLinebreak);
-		inset->read(lex);
-		par.insertInset(par.size(), inset.release(), font, change);
-	} else if (token == "\\newline") {
-		auto_ptr<Inset> inset(new InsetNewline);
-		inset->read(lex);
-		par.insertInset(par.size(), inset.release(), font, change);
 	} else if (token == "\\LyXTable") {
 		auto_ptr<Inset> inset(new InsetTabular(buf));
 		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 InsetNewpage, font, change);
-	} else if (token == "\\pagebreak") {
-		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") {
@@ -316,7 +278,7 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex,
 		    || token == "\\end_deeper") {
 			lex.pushToken(token);
 			lyxerr << "Paragraph ended in line "
-			       << lex.getLineNo() << "\n"
+			       << lex.lineNumber() << "\n"
 			       << "Missing \\end_layout.\n";
 			break;
 		}
@@ -331,12 +293,41 @@ 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);
 }
 
 
@@ -350,18 +341,18 @@ double Text::spacing(Buffer const & buffer, Paragraph const & par) const
 
 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();
 
 	DocumentClass const & tclass = cur.buffer().params().documentClass();
-	LayoutPtr const & layout = cpar.layout();
+	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
@@ -374,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();
@@ -427,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);
 
@@ -437,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) {
@@ -539,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;
@@ -580,8 +571,8 @@ void Text::charInserted(Cursor & cur)
 	    && par.isLetter(cur.pos() - 2)
 	    && !par.isLetter(cur.pos() - 1)) {
 		// get the word in front of cursor
-		BOOST_ASSERT(this == cur.text());
-		cur.paragraph().updateWords(cur.buffer(), cur.top());
+		LASSERT(this == cur.text(), /**/);
+		cur.paragraph().updateWords(cur.top());
 	}
 }
 
@@ -591,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(), /**/);
+
+	pit_type pit = cur.pit();
+	pos_type pos = cur.pos();
+	Paragraph & par = cur.paragraph();
 
-	Cursor old = cur;
+	// Skip through puctuation and spaces.
+	while (pos != 0 && par.isChar(pos - 1))
+		--pos;
 
-	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 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);
@@ -651,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);
@@ -661,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;
@@ -807,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 {
@@ -823,7 +905,7 @@ void Text::deleteWordForward(Cursor & cur)
 
 void Text::deleteWordBackward(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	if (cur.lastpos() == 0)
 		cursorBackward(cur);
 	else {
@@ -840,7 +922,7 @@ 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;
 
@@ -887,7 +969,7 @@ void Text::changeCase(Cursor & cur, TextCase action)
 
 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)
@@ -922,7 +1004,7 @@ bool Text::handleBibitems(Cursor & cur)
 
 bool Text::erase(Cursor & cur)
 {
-	BOOST_ASSERT(this == cur.text());
+	LASSERT(this == cur.text(), /**/);
 	bool needsUpdate = false;
 	Paragraph & par = cur.paragraph();
 
@@ -969,7 +1051,7 @@ 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;
 
@@ -1004,8 +1086,8 @@ bool Text::backspacePos0(Cursor & cur)
 	// Correction: Pasting is always allowed with standard-layout
 	// or the empty layout.
 	else if (par.layout() == prevpar.layout()
-		 || par.layout() == tclass.defaultLayout()
-		 || par.layout() == tclass.emptyLayout()) {
+		 || tclass.isDefaultLayout(par.layout())
+		 || tclass.isEmptyLayout(par.layout())) {
 		cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
 		mergeParagraph(bufparams, plist, prevcur.pit());
 		needsUpdate = true;
@@ -1022,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)
@@ -1071,7 +1153,7 @@ 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;
@@ -1206,7 +1288,7 @@ bool Text::read(Buffer const & buf, Lexer & lex,
 			// register the words in the global word list
 			CursorSlice sl = CursorSlice(*insetPtr);
 			sl.pit() = pars_.size() - 1;
-			pars_.back().updateWords(buf, sl);
+			pars_.back().updateWords(sl);
 		} else if (token == "\\begin_deeper") {
 			++depth;
 		} else if (token == "\\end_deeper") {
@@ -1224,7 +1306,7 @@ bool Text::read(Buffer const & buf, Lexer & lex,
 // 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;
@@ -1305,10 +1387,10 @@ 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(false);
+	docstring par_text = pars_[pit].asString();
 	string piece;
 	// the return string of math matrices might contain linebreaks
 	par_text = subst(par_text, '\n', '-');
@@ -1332,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;
@@ -1380,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();
 
@@ -1449,4 +1531,48 @@ void Text::setMacrocontextPosition(DocIterator const & 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