X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText.cpp;h=cf3263ba2bb1d98892acb8bebbdcef5d2ebd0ad6;hb=51ac7d895cc7a9c4ad91131d0b4734395366d04b;hp=6e2ee99964f6bd948eebc9a79c0a153e4c2ee72a;hpb=21ff30cc380e341369b478ea26fa418d0ffe4cdb;p=lyx.git

diff --git a/src/Text.cpp b/src/Text.cpp
index 6e2ee99964..cf3263ba2b 100644
--- a/src/Text.cpp
+++ b/src/Text.cpp
@@ -26,8 +26,8 @@
 #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"
@@ -42,18 +42,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 "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/InsetNewpage.h"
@@ -81,8 +79,6 @@ namespace lyx {
 using cap::cutSelection;
 using cap::pasteParagraphList;
 
-using frontend::FontMetrics;
-
 namespace {
 
 void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
@@ -101,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);
@@ -113,15 +121,17 @@ 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);
 
@@ -188,49 +198,26 @@ 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 == "\\linebreak") {
 		auto_ptr<Inset> inset(new InsetLinebreak);
-		inset->read(buf, lex);
+		inset->read(lex);
 		par.insertInset(par.size(), inset.release(), font, change);
 	} else if (token == "\\newline") {
 		auto_ptr<Inset> inset(new InsetNewline);
-		inset->read(buf, lex);
+		inset->read(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") {
@@ -322,17 +309,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();
@@ -347,13 +362,13 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 	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
@@ -366,12 +381,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();
@@ -388,9 +403,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());
 	}
 
@@ -427,7 +444,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) {
@@ -440,8 +457,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) &&
@@ -459,7 +476,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_);
 				}
@@ -492,7 +509,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();
@@ -505,7 +522,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);
 		}
@@ -553,6 +570,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;
@@ -562,6 +581,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
+		BOOST_ASSERT(this == cur.text());
+		cur.paragraph().updateWords(cur.top());
+	}
 }
 
 
@@ -866,33 +894,36 @@ 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)
 		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;
 }
 
 
@@ -906,11 +937,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();
-		}
-		cur.checkBufferStructure();
+
+		if (was_inset)
+			updateLabels(cur.buffer());
+		else
+			cur.checkBufferStructure();
 		needsUpdate = true;
 	} else {
 		if (cur.pit() == cur.lastpit())
@@ -948,7 +983,7 @@ bool Text::backspacePos0(Cursor & cur)
 	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;
@@ -974,8 +1009,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;
@@ -1019,8 +1056,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);
-		cur.checkBufferStructure();
+		if (was_inset)
+			updateLabels(cur.buffer());
+		else
+			cur.checkBufferStructure();
 	}
 
 	if (cur.pos() == cur.lastpos())
@@ -1067,7 +1108,7 @@ 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() = min(cur.lastpit(), spit);
@@ -1080,7 +1121,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) {
@@ -1112,7 +1153,7 @@ void Text::getWord(CursorSlice & from, CursorSlice & to,
 		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();
 }
@@ -1124,7 +1165,7 @@ void Text::write(Buffer const & buf, ostream & os) const
 	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)
@@ -1132,7 +1173,8 @@ void Text::write(Buffer const & buf, 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;
 
@@ -1161,12 +1203,17 @@ 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") {
@@ -1265,10 +1312,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(cur.buffer(), false);
+	docstring par_text = pars_[pit].asString(false);
 	string piece;
 	// the return string of math matrices might contain linebreaks
 	par_text = subst(par_text, '\n', '-');
@@ -1292,7 +1339,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;
@@ -1409,4 +1456,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(), false);
+}
+
+
+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*/)
+{	
+	BOOST_ASSERT(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