X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=ab9ba6d170a34ac7faba5461f7d2b9b6bcf8673e;hb=21226de2b87a86be19fff025cace3d286a75aa76;hp=f5a8e786dd401e6ca45e44670cc4b62d73a9ff2b;hpb=85a5ea7bfc80e179a61a99f2955455e84d3384cc;p=lyx.git

diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C
index f5a8e786dd..ab9ba6d170 100644
--- a/src/paragraph_pimpl.C
+++ b/src/paragraph_pimpl.C
@@ -16,20 +16,38 @@
 
 #include "paragraph_pimpl.h"
 #include "texrow.h"
+#include "language.h"
 #include "bufferparams.h"
 #include "encoding.h"
 #include "lyxrc.h"
 #include "debug.h"
+#include "lyxtextclasslist.h"
 
-extern int tex_code_break_column;
+#include "support/LAssert.h"
 
+using lyx::pos_type;
+
+extern int tex_code_break_column;
 
-// Initialization of the counter for the paragraph id's,
-unsigned int Paragraph::Pimpl::paragraph_id = 0;
 
 // Initialize static member.
 ShareContainer<LyXFont> Paragraph::Pimpl::FontTable::container;
+// Initialization of the counter for the paragraph id's,
+unsigned int Paragraph::Pimpl::paragraph_id = 0;
 
+namespace {
+ 
+string special_phrases[][2] = {
+	{ "LyX", "\\LyX{}" },
+	{ "TeX", "\\TeX{}" },
+	{ "LaTeX2e", "\\LaTeXe{}" },
+	{ "LaTeX", "\\LaTeX{}" },
+	};
+ 
+size_t phrases_nr = sizeof(special_phrases)/sizeof(special_phrases[0]);
+ 
+} // namespace anon
+ 
 
 Paragraph::Pimpl::Pimpl(Paragraph * owner)
 	: owner_(owner)
@@ -39,12 +57,16 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner)
 }
 
 
-Paragraph::Pimpl::Pimpl(Paragraph::Pimpl const & p, Paragraph * owner)
-	: owner_(owner)
+Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner, bool same_ids)
+	: params(p.params), owner_(owner)
 {
 	inset_owner = p.inset_owner;
 	text = p.text;
 	fontlist = p.fontlist;
+	if (same_ids)
+		id_ = p.id_;
+	else
+		id_ = paragraph_id++;
 }
 
 
@@ -61,8 +83,7 @@ void Paragraph::Pimpl::setContentsFromPar(Paragraph const * par)
 }
 
 
-Paragraph::value_type
-Paragraph::Pimpl::getChar(Paragraph::size_type pos) const
+Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const
 {
 	lyx::Assert(pos <= size());
 	// This is stronger, and I belive that this is the assertion
@@ -76,16 +97,14 @@ Paragraph::Pimpl::getChar(Paragraph::size_type pos) const
 }
 
 
-void Paragraph::Pimpl::setChar(Paragraph::size_type pos,
-			       Paragraph::value_type c)
+void Paragraph::Pimpl::setChar(pos_type pos, value_type c)
 {
 	text[pos] = c;
 }
 
 
-void Paragraph::Pimpl::insertChar(Paragraph::size_type pos,
-				  Paragraph::value_type c,
-				  LyXFont const & font)
+void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
+                                  LyXFont const & font)
 {
 	lyx::Assert(pos <= size());
 
@@ -93,25 +112,28 @@ void Paragraph::Pimpl::insertChar(Paragraph::size_type pos,
 
 	// Update the font table.
 	FontTable search_font(pos, LyXFont());
-	for (FontList::iterator it = lower_bound(fontlist.begin(),
-						 fontlist.end(),
-						 search_font, matchFT());
+	for (FontList::iterator it = std::lower_bound(fontlist.begin(),
+	                                              fontlist.end(),
+	                                              search_font, matchFT());
 	     it != fontlist.end(); ++it)
-		(*it).pos((*it).pos() + 1);
+	{
+		it->pos(it->pos() + 1);
+	}
    
 	// Update the inset table.
 	InsetTable search_inset(pos, 0);
-	for (InsetList::iterator it = lower_bound(owner_->insetlist.begin(),
-						  owner_->insetlist.end(),
-						  search_inset, matchIT());
+	for (InsetList::iterator it = std::lower_bound(owner_->insetlist.begin(),
+	                                               owner_->insetlist.end(),
+	                                               search_inset, matchIT());
 	     it != owner_->insetlist.end(); ++it)
-		++(*it).pos;
-
+	{
+		++it->pos;
+	}
 	owner_->setFont(pos, font);
 }
 
 
-void Paragraph::Pimpl::insertInset(Paragraph::size_type pos,
+void Paragraph::Pimpl::insertInset(pos_type pos,
 				   Inset * inset, LyXFont const & font)
 {
 	lyx::Assert(inset);
@@ -122,14 +144,15 @@ void Paragraph::Pimpl::insertInset(Paragraph::size_type pos,
 	
 	// Add a new entry in the inset table.
 	InsetTable search_inset(pos, 0);
-	InsetList::iterator it = lower_bound(owner_->insetlist.begin(),
-					     owner_->insetlist.end(),
-					     search_inset, matchIT());
-	if (it != owner_->insetlist.end() && (*it).pos == pos) {
+	InsetList::iterator it = std::lower_bound(owner_->insetlist.begin(),
+						  owner_->insetlist.end(),
+						  search_inset, matchIT());
+	if (it != owner_->insetlist.end() && it->pos == pos) {
 		lyxerr << "ERROR (Paragraph::InsertInset): "
 			"there is an inset in position: " << pos << std::endl;
 	} else {
 		owner_->insetlist.insert(it, InsetTable(pos, inset));
+		inset->parOwner(owner_);
 	}
 	
 	if (inset_owner)
@@ -137,7 +160,7 @@ void Paragraph::Pimpl::insertInset(Paragraph::size_type pos,
 }
 
 
-void Paragraph::Pimpl::erase(Paragraph::size_type pos)
+void Paragraph::Pimpl::erase(pos_type pos)
 {
 	lyx::Assert(pos < size());
 	// if it is an inset, delete the inset entry 
@@ -145,11 +168,11 @@ void Paragraph::Pimpl::erase(Paragraph::size_type pos)
 		// find the entry
 		InsetTable search_inset(pos, 0);
 		InsetList::iterator it =
-			lower_bound(owner_->insetlist.begin(),
-				    owner_->insetlist.end(),
-				    search_inset, matchIT());
-		if (it != owner_->insetlist.end() && (*it).pos == pos) {
-			delete (*it).inset;
+			std::lower_bound(owner_->insetlist.begin(),
+					 owner_->insetlist.end(),
+					 search_inset, matchIT());
+		if (it != owner_->insetlist.end() && it->pos == pos) {
+			delete it->inset;
 			owner_->insetlist.erase(it);
 		}
 	}
@@ -160,13 +183,13 @@ void Paragraph::Pimpl::erase(Paragraph::size_type pos)
 	FontTable search_font(pos, LyXFont());
 	
 	FontList::iterator it =
-		lower_bound(fontlist.begin(),
+		std::lower_bound(fontlist.begin(),
 			    fontlist.end(),
 			    search_font, matchFT());
-	if (it != fontlist.end() && (*it).pos() == pos &&
+	if (it != fontlist.end() && it->pos() == pos &&
 	    (pos == 0 || 
 	     (it != fontlist.begin() 
-	      && (*(it - 1)).pos() == pos - 1))) {
+	      && boost::prior(it)->pos() == pos - 1))) {
 		// If it is a multi-character font
 		// entry, we just make it smaller
 		// (see update below), otherwise we
@@ -184,44 +207,40 @@ void Paragraph::Pimpl::erase(Paragraph::size_type pos)
 	// Update all other entries.
 	FontList::iterator fend = fontlist.end();
 	for (; it != fend; ++it)
-		(*it).pos((*it).pos() - 1);
+		it->pos(it->pos() - 1);
 	
 	// Update the inset table.
 	InsetTable search_inset(pos, 0);
 	InsetList::iterator lend = owner_->insetlist.end();
 	for (InsetList::iterator it =
-		     upper_bound(owner_->insetlist.begin(),
-				 lend,
-				 search_inset, matchIT());
+		     std::upper_bound(owner_->insetlist.begin(),
+				      lend,
+				      search_inset, matchIT());
 	     it != lend; ++it)
-		--(*it).pos;
+		--it->pos;
 }
 
 
 void Paragraph::Pimpl::simpleTeXBlanks(std::ostream & os, TexRow & texrow,
-				       Paragraph::size_type const i,
-				       int & column, LyXFont const & font,
-				       LyXLayout const & style)
+                                       pos_type const i,
+                                       int & column, LyXFont const & font,
+                                       LyXLayout const & style)
 {
+	if (style.pass_thru) return;
 	if (column > tex_code_break_column
 	    && i 
-	    && owner_->getChar(i - 1) != ' '
-	    && (i < owner_->size() - 1)
-#ifndef NO_LATEX
-	    // In LaTeX mode, we don't want to
-	    // break lines since some commands
-	    // do not like this
-	    && ! (font.latex() == LyXFont::ON)
-#endif
+	    && getChar(i - 1) != ' '
+	    && (i < size() - 1)
 	    // same in FreeSpacing mode
 	    && !style.free_spacing
+		&& !owner_->isFreeSpacing()
 	    // In typewriter mode, we want to avoid 
 	    // ! . ? : at the end of a line
 	    && !(font.family() == LyXFont::TYPEWRITER_FAMILY
-		 && (owner_->getChar(i-1) == '.'
-		     || owner_->getChar(i-1) == '?' 
-		     || owner_->getChar(i-1) == ':'
-		     || owner_->getChar(i-1) == '!'))) {
+		 && (getChar(i - 1) == '.'
+		     || getChar(i - 1) == '?' 
+		     || getChar(i - 1) == ':'
+		     || getChar(i - 1) == '!'))) {
 		if (tex_code_break_column == 0) {
 			// in batchmode we need LaTeX to still
 			// see it as a space not as an extra '\n'
@@ -232,21 +251,31 @@ void Paragraph::Pimpl::simpleTeXBlanks(std::ostream & os, TexRow & texrow,
 		texrow.newline();
 		texrow.start(owner_, i + 1);
 		column = 0;
-	} else
-#ifndef NO_LATEX
-		if (font.latex() == LyXFont::OFF) {
-#endif
-		if (style.free_spacing) {
-			os << '~';
-		} else {
-			os << ' ';
-		}
-#ifndef NO_LATEX
+	} else if (style.free_spacing) {
+		os << '~';
+	} else {
+		os << ' ';
 	}
-#endif
 }
 
 
+bool Paragraph::Pimpl::isTextAt(BufferParams const & bp,
+				string const & str, pos_type pos)
+{
+	LyXFont const & font = owner_->getFont(bp, pos);
+ 
+	for (string::size_type i = 0; i < str.length(); ++i) {
+		if (pos + static_cast<pos_type>(i) >= size())
+			return false;
+		if (str[i] != getChar(pos + i))
+			return false;
+		if (owner_->getFont(bp, pos + i) != font)
+			return false;
+	}
+	return true;
+}
+
+ 
 void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
 					     BufferParams const & bparams,
 					     std::ostream & os,
@@ -257,10 +286,14 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
 					     LyXFont & basefont,
 					     bool & open_font,
 					     LyXLayout const & style,
-					     Paragraph::size_type & i,
+					     pos_type & i,
 					     int & column,
-					     Paragraph::value_type const c)
+					     value_type const c)
 {
+	if (style.pass_thru) {
+		if (c != '\0') os << c;
+		return;
+	}
 	// Two major modes:  LaTeX or plain
 	// Handle here those cases common to both modes
 	// and then split to handle the two modes separately.
@@ -280,19 +313,20 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
 			}
 
 			int tmp = inset->latex(buf, os, moving_arg,
-					       style.free_spacing);
+			                       style.free_spacing);
 
 			if (close)
 				os << "}";
 
 			if (tmp) {
+				for (int j = 0; j < tmp; ++j) {
+					texrow.newline();
+				}
+				texrow.start(owner_, i + 1);
 				column = 0;
 			} else {
 				column += int(os.tellp()) - len;
 			}
-			for (; tmp--;) {
-				texrow.newline();
-			}
 		}
 	}
 	break;
@@ -304,7 +338,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
 								    basefont);
 			open_font = false;
 		}
-		basefont = owner_->getFont(bparams, -1);
+		basefont = owner_->getLayoutFont(bparams);
 		running_font = basefont;
 		break;
 
@@ -315,202 +349,161 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
 
 	default:
 		// And now for the special cases within each mode
-#ifndef NO_LATEX
-		// Are we in LaTeX mode?
-		if (font.latex() == LyXFont::ON) {
-			// at present we only have one option
-			// but I'll leave it as a switch statement
-			// so its simpler to extend. (ARRae)
-			switch (c) {
-			default:
-				// make sure that we will not print
-				// error generating chars to the tex
-				// file. This test would not be needed
-				// if it were done in the buffer
-				// itself.
-				if (c != '\0') {
-					os << c;
+
+		switch (c) {
+		case '\\': 
+			os << "\\textbackslash{}";
+			column += 15;
+			break;
+			
+		case '°': case '±': case '²': case '³':  
+		case '×': case '÷': case '¹': case 'ª':
+		case 'º': case '¬': case 'µ':
+			if ((bparams.inputenc == "latin1" ||
+			     bparams.inputenc == "latin9") ||
+			    (bparams.inputenc == "auto" &&
+			     (font.language()->encoding()->LatexName()
+			      == "latin1" ||
+			      font.language()->encoding()->LatexName()
+			      == "latin9"))) {
+				os << "\\ensuremath{"
+				   << c
+				   << '}';
+				column += 13;
+			} else {
+				os << c;
+			}
+			break;
+			
+		case '|': case '<': case '>':
+			// In T1 encoding, these characters exist
+			if (lyxrc.fontenc == "T1") {
+				os << c;
+				//... but we should avoid ligatures
+				if ((c == '>' || c == '<')
+				    && i <= size() - 2
+				    && getChar(i + 1) == c) {
+					//os << "\\textcompwordmark{}";
+					// Jean-Marc, have a look at
+					// this. I think this works
+					// equally well:
+					os << "\\,{}";
+					// Lgb
+					column += 19;
 				}
 				break;
 			}
-		} else {
-#endif
-			// Plain mode (i.e. not LaTeX)
-			switch (c) {
-			case '\\': 
-				os << "\\textbackslash{}";
-				column += 15;
+			// Typewriter font also has them
+			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
+				os << c;
 				break;
-		
-			case '°': case '±': case '²': case '³':  
-			case '×': case '÷': case '¹': case 'ª':
-			case 'º': case '¬': case 'µ':
-				if (bparams.inputenc == "latin1" ||
-				    (bparams.inputenc == "auto" &&
-				     font.language()->encoding()->LatexName()
-				     == "latin1")) {
-					os << "\\ensuremath{"
-					   << c
-					   << '}';
-					column += 13;
-				} else {
-					os << c;
-				}
-				break;
-
-			case '|': case '<': case '>':
-				// In T1 encoding, these characters exist
-				if (lyxrc.fontenc == "T1") {
-					os << c;
-					//... but we should avoid ligatures
-					if ((c == '>' || c == '<')
-					    && i <= owner_->size() - 2
-					    && owner_->getChar(i + 1) == c) {
-						//os << "\\textcompwordmark{}";
-						// Jean-Marc, have a look at
-						// this. I think this works
-						// equally well:
-						os << "\\,{}";
-						// Lgb
-						column += 19;
-					}
-					break;
-				}
-				// Typewriter font also has them
-				if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
-					os << c;
-					break;
-				} 
-				// Otherwise, we use what LaTeX
-				// provides us.
-				switch (c) {
-				case '<':
-					os << "\\textless{}";
-					column += 10;
-					break;
-				case '>':
-					os << "\\textgreater{}";
-					column += 13;
-					break;
-				case '|':
-					os << "\\textbar{}";
-					column += 9;
-					break;
-				}
+			} 
+			// Otherwise, we use what LaTeX
+			// provides us.
+			switch (c) {
+			case '<':
+				os << "\\textless{}";
+				column += 10;
 				break;
-
-			case '-': // "--" in Typewriter mode -> "-{}-"
-				if (i <= owner_->size() - 2
-				    && owner_->getChar(i + 1) == '-'
-				    && font.family() == LyXFont::TYPEWRITER_FAMILY) {
-					os << "-{}";
-					column += 2;
-				} else {
-					os << '-';
-				}
+			case '>':
+				os << "\\textgreater{}";
+				column += 13;
 				break;
-
-			case '\"': 
-				os << "\\char`\\\"{}";
+			case '|':
+				os << "\\textbar{}";
 				column += 9;
 				break;
-
-			case '£':
-				if (bparams.inputenc == "default") {
-					os << "\\pounds{}";
-					column += 8;
-				} else {
-					os << c;
-				}
-				break;
-
-			case '$': case '&':
-			case '%': case '#': case '{':
-			case '}': case '_':
-				os << '\\' << c;
-				column += 1;
-				break;
-
-			case '~':
-				os << "\\textasciitilde{}";
-				column += 16;
-				break;
-
-			case '^':
-				os << "\\textasciicircum{}";
-				column += 17;
-				break;
-
-			case '*': case '[': case ']':
-				// avoid being mistaken for optional arguments
-				os << '{' << c << '}';
+			}
+			break;
+			
+		case '-': // "--" in Typewriter mode -> "-{}-"
+			if (i <= size() - 2
+			    && getChar(i + 1) == '-'
+			    && font.family() == LyXFont::TYPEWRITER_FAMILY) {
+				os << "-{}";
 				column += 2;
-				break;
-
-			case ' ':
-				// Blanks are printed before font switching.
-				// Sure? I am not! (try nice-latex)
-				// I am sure it's correct. LyX might be smarter
-				// in the future, but for now, nothing wrong is
-				// written. (Asger)
-				break;
-
-			default:
-				/* idea for labels --- begin*/
-				// Check for "LyX"
-				if (c ==  'L'
-				    && i <= owner_->size() - 3
-				    && font.family() != LyXFont::TYPEWRITER_FAMILY
-				    && owner_->getChar(i + 1) == 'y'
-				    && owner_->getChar(i + 2) == 'X') {
-					os << "\\LyX{}";
-					i += 2;
-					column += 5;
-				}
-				// Check for "TeX"
-				else if (c == 'T'
-					 && i <= owner_->size() - 3
-					 && font.family() != LyXFont::TYPEWRITER_FAMILY
-					 && owner_->getChar(i + 1) == 'e'
-					 && owner_->getChar(i + 2) == 'X') {
-					os << "\\TeX{}";
-					i += 2;
-					column += 5;
-				}
-				// Check for "LaTeX2e"
-				else if (c == 'L'
-					 && i <= owner_->size() - 7
-					 && font.family() != LyXFont::TYPEWRITER_FAMILY
-					 && owner_->getChar(i + 1) == 'a'
-					 && owner_->getChar(i + 2) == 'T'
-					 && owner_->getChar(i + 3) == 'e'
-					 && owner_->getChar(i + 4) == 'X'
-					 && owner_->getChar(i + 5) == '2'
-					 && owner_->getChar(i + 6) == 'e') {
-					os << "\\LaTeXe{}";
-					i += 6;
-					column += 8;
-				}
-				// Check for "LaTeX"
-				else if (c == 'L'
-					 && i <= owner_->size() - 5
-					 && font.family() != LyXFont::TYPEWRITER_FAMILY
-					 && owner_->getChar(i + 1) == 'a'
-					 && owner_->getChar(i + 2) == 'T'
-					 && owner_->getChar(i + 3) == 'e'
-					 && owner_->getChar(i + 4) == 'X') {
-					os << "\\LaTeX{}";
-					i += 4;
-					column += 7;
-					/* idea for labels --- end*/ 
-				} else if (c != '\0') {
+			} else {
+				os << '-';
+			}
+			break;
+			
+		case '\"': 
+			os << "\\char`\\\"{}";
+			column += 9;
+			break;
+			
+		case '£':
+			if (bparams.inputenc == "default") {
+				os << "\\pounds{}";
+				column += 8;
+			} else {
+				os << c;
+			}
+			break;
+			
+		case '$': case '&':
+		case '%': case '#': case '{':
+		case '}': case '_':
+			os << '\\' << c;
+			column += 1;
+			break;
+			
+		case '~':
+			os << "\\textasciitilde{}";
+			column += 16;
+			break;
+			
+		case '^':
+			os << "\\textasciicircum{}";
+			column += 17;
+			break;
+			
+		case '*': case '[': case ']':
+			// avoid being mistaken for optional arguments
+			os << '{' << c << '}';
+			column += 2;
+			break;
+
+		case ' ':
+			// Blanks are printed before font switching.
+			// Sure? I am not! (try nice-latex)
+		       	// I am sure it's correct. LyX might be smarter
+		       	// in the future, but for now, nothing wrong is
+		       	// written. (Asger)
+			break;
+
+		default:
+ 
+			// I assume this is hack treating typewriter as verbatim
+			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
+				if (c != '\0') {
 					os << c;
 				}
 				break;
 			}
-#ifndef NO_LATEX
+		
+			// LyX, LaTeX etc.
+ 
+			// FIXME: if we have "LaTeX" with a font change in the middle (before
+			// the 'T', then the "TeX" part is still special cased. Really we
+			// should only operate this on "words" for some definition of word
+ 
+			size_t pnr = 0;
+ 
+			for (; pnr < phrases_nr; ++pnr) {
+				if (isTextAt(bparams, special_phrases[pnr][0], i)) {
+					os << special_phrases[pnr][1];
+					i += special_phrases[pnr][0].length() - 1;
+					column += special_phrases[pnr][1].length() - 1;
+					break;
+				}
+			}
+
+			if (pnr == phrases_nr && c != '\0') {
+				os << c;
+			}
+			break;
 		}
-#endif
 	}
 }
 
@@ -539,3 +532,46 @@ Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf,
 }
 
 
+Paragraph * Paragraph::Pimpl::getParFromID(int id) const
+{
+	InsetList::const_iterator cit = owner_->insetlist.begin();
+	InsetList::const_iterator lend = owner_->insetlist.end();
+	Paragraph * result;
+	for (; cit != lend; ++cit) {
+		if ((result = cit->inset->getParFromID(id)))
+			return result;
+	}
+	return 0;
+}
+
+
+LyXFont const Paragraph::Pimpl::realizeFont(LyXFont const & font,
+					    BufferParams const & bparams) const
+{
+	LyXFont tmpfont(font);
+	
+	// check for environment font information
+	char par_depth = owner_->getDepth();
+	Paragraph const * par = owner_;
+	while (par && par->getDepth() && !tmpfont.resolved()) {
+		par = par->outerHook();
+		if (par) {
+			tmpfont.realize(textclasslist.
+					Style(bparams.textclass,
+					      par->getLayout()).font
+#ifdef INHERIT_LANGUAGE
+					, bparams.language
+#endif
+					);
+			par_depth = par->getDepth();
+		}
+	}
+
+	tmpfont.realize(textclasslist.TextClass(bparams.textclass)
+			.defaultfont()
+#ifdef INHERIT_LANGUAGE
+		, bparams.language
+#endif
+		);
+	return tmpfont;	
+}