X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=f4da5dd0b847fee8702d772a1c9c17ff3f022c79;hb=5702f22ef0ea3d167fc5f327002d7006eef657b4;hp=d4ccf901e0d569690f16770c23d022b0cd5e3272;hpb=63ab8b351789ec3e77feba3918548627dbaa1347;p=lyx.git

diff --git a/src/text.C b/src/text.C
index d4ccf901e0..f4da5dd0b8 100644
--- a/src/text.C
+++ b/src/text.C
@@ -100,10 +100,10 @@ int LyXText::workWidth(BufferView * bview, Inset * inset) const
 		int dummy_y;
 		Row * row = getRow(par, pos, dummy_y);
 		Row * frow = row;
-		while(frow->previous() && frow->par() == frow->previous()->par())
+		while (frow->previous() && frow->par() == frow->previous()->par())
 			frow = frow->previous();
 		unsigned int maxw = 0;
-		while(frow->next() && frow->par() == frow->next()->par()) {
+		while (frow->next() && frow->par() == frow->next()->par()) {
 			if ((frow != row) && (maxw < frow->width()))
 				maxw = frow->width();
 			frow = frow->next();
@@ -181,7 +181,7 @@ unsigned char LyXText::transformChar(unsigned char c, Paragraph * par,
 // Lgb
 
 int LyXText::singleWidth(BufferView * bview, Paragraph * par,
-			 pos_type pos) const
+                         pos_type pos) const
 {
 	char const c = par->getChar(pos);
 	return singleWidth(bview, par, pos, c);
@@ -215,7 +215,10 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par,
 	} else if (c == Paragraph::META_INSET) {
 		Inset * tmpinset = par->getInset(pos);
 		if (tmpinset) {
-#if 0 // seems not to be needed, but ...
+#if 1
+			// this IS needed otherwise on initialitation we don't get the fill
+			// of the row right (ONLY on initialization if we read a file!)
+			// should be changed! (Jug 20011204)
 			tmpinset->update(bview, font);
 #endif
 			return tmpinset->width(bview, font);
@@ -407,212 +410,243 @@ bool LyXText::isBoundary(Buffer const * buf, Paragraph * par,
 	return rtl != rtl2;
 }
 
+void LyXText::drawNewline(DrawRowParams & p, pos_type const pos)
+{
+	// Draw end-of-line marker
+	LyXFont const font = getFont(p.bv->buffer(), p.row->par(), pos);
+	int const wid = lyxfont::width('n', font);
+	int const asc = lyxfont::maxAscent(font);
+	int const y = p.yo + p.row->baseline();
+	int xp[3];
+	int yp[3];
+		
+	yp[0] = int(y - 0.875 * asc * 0.75);
+	yp[1] = int(y - 0.500 * asc * 0.75);
+	yp[2] = int(y - 0.125 * asc * 0.75);
+ 
+	if (bidi_level(pos) % 2 == 0) {
+		xp[0] = int(p.x + wid * 0.375);
+		xp[1] = int(p.x);
+		xp[2] = int(p.x + wid * 0.375);
+	} else { 
+		xp[0] = int(p.x + wid * 0.625);
+		xp[1] = int(p.x + wid);
+		xp[2] = int(p.x + wid * 0.625);
+	}
+ 
+	p.pain->lines(xp, yp, 3, LColor::eolmarker);
+ 
+	yp[0] = int(y - 0.500 * asc * 0.75);
+	yp[1] = int(y - 0.500 * asc * 0.75);
+	yp[2] = int(y - asc * 0.75);
+ 
+	if (bidi_level(pos) % 2 == 0) {
+		xp[0] = int(p.x);
+		xp[1] = int(p.x + wid);
+		xp[2] = int(p.x + wid);
+	} else {
+		xp[0] = int(p.x + wid);
+		xp[1] = int(p.x);
+		xp[2] = int(p.x);
+	}
+ 
+	p.pain->lines(xp, yp, 3, LColor::eolmarker);
+
+	p.x += wid;
+}
 
-void LyXText::draw(BufferView * bview, Row const * row,
-                   pos_type & vpos, int offset, float & x, bool cleared)
+ 
+void LyXText::drawInset(DrawRowParams & p, pos_type const pos)
 {
-	Painter & pain = bview->painter();
-	
-	pos_type pos = vis2log(vpos);
-	char c = row->par()->getChar(pos);
-	float tmpx = x;
+	Inset * inset = p.row->par()->getInset(pos);
 
-	if (IsNewlineChar(c)) {
-		++vpos;
-		// Draw end-of-line marker
-		LyXFont const font = getFont(bview->buffer(), row->par(), pos);
-		int const wid = lyxfont::width('n', font);
-		int const asc = lyxfont::maxAscent(font);
-		int const y = offset + row->baseline();
-		int xp[3];
-		int yp[3];
-		
-		if (bidi_level(pos) % 2 == 0) {
-			xp[0] = int(x + wid * 0.375);
-			yp[0] = int(y - 0.875 * asc * 0.75);
-			
-			xp[1] = int(x);
-			yp[1] = int(y - 0.500 * asc * 0.75);
-			
-			xp[2] = int(x + wid * 0.375);
-			yp[2] = int(y - 0.125 * asc * 0.75);
-			
-			pain.lines(xp, yp, 3, LColor::eolmarker);
-			
-			xp[0] = int(x);
-			yp[0] = int(y - 0.500 * asc * 0.75);
-			
-			xp[1] = int(x + wid);
-			yp[1] = int(y - 0.500 * asc * 0.75);
-			
-			xp[2] = int(x + wid);
-			yp[2] = int(y - asc * 0.75);
-			
-			pain.lines(xp, yp, 3, LColor::eolmarker);
-		} else {
-			xp[0] = int(x + wid * 0.625);
-			yp[0] = int(y - 0.875 * asc * 0.75);
-			
-			xp[1] = int(x + wid);
-			yp[1] = int(y - 0.500 * asc * 0.75);
-			
-			xp[2] = int(x + wid * 0.625);
-			yp[2] = int(y - 0.125 * asc * 0.75);
-			
-			pain.lines(xp, yp, 3, LColor::eolmarker);
-			
-			xp[0] = int(x + wid);
-			yp[0] = int(y - 0.500 * asc * 0.75);
-			
-			xp[1] = int(x);
-			yp[1] = int(y - 0.500 * asc * 0.75);
-			
-			xp[2] = int(x);
-			yp[2] = int(y - asc * 0.75);
-			
-			pain.lines(xp, yp, 3, LColor::eolmarker);
-		}
-		x += wid;
+	// FIXME: shouldn't happen
+	if (!inset) {
 		return;
 	}
+ 
+	LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos);
+ 
+	inset->update(p.bv, font, false);
+	inset->draw(p.bv, font, p.yo + p.row->baseline(), p.x, p.cleared);
+ 
+	if (!need_break_row && !inset_owner 
+		&& p.bv->text->status() == CHANGED_IN_DRAW) {
+		Row * prev = p.row->previous();
+		if (prev && prev->par() == p.row->par()) {
+			breakAgainOneRow(p.bv, prev);
+		} 
+		setCursor(p.bv, cursor.par(), cursor.pos());
+		need_break_row = p.row;
+	}
+}
 
-	LyXFont font = getFont(bview->buffer(), row->par(), pos);
-	LyXFont font2 = font;
 
-	if (c == Paragraph::META_INSET) {
-		Inset * tmpinset = row->par()->getInset(pos);
-		if (tmpinset) {
-			tmpinset->update(bview, font, false);
-			tmpinset->draw(bview, font, offset+row->baseline(), x,
-			               cleared);
-			if (!need_break_row && !inset_owner &&
-			    bview->text->status() == CHANGED_IN_DRAW)
-			{
-				if (row->previous() && row->previous()->par() == row->par())
-					breakAgainOneRow(bview, row->previous());
-				setCursor(bview, cursor.par(), cursor.pos());
-				need_break_row = const_cast<Row *>(row);
+void LyXText::drawForeignMark(DrawRowParams & p, float const orig_x, LyXFont const & orig_font)
+{
+	if (!lyxrc.mark_foreign_language)
+		return; 
+	if (orig_font.language() == latex_language)
+		return;
+	if (orig_font.language() == p.bv->buffer()->params.language)
+		return;
+ 
+	int const y = p.yo + p.row->height() - 1;
+	p.pain->line(int(orig_x), y, int(p.x), y, LColor::language);
+}
+ 
+
+void LyXText::drawHebrewComposeChar(DrawRowParams & p, pos_type & vpos)
+{
+	pos_type pos = vis2log(vpos);
+ 
+	string str;
+
+	// first char 
+	char c = p.row->par()->getChar(pos);
+	str += c;
+	++vpos; 
+ 
+	LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos);
+	int const width = lyxfont::width(c, font);
+	int dx = 0;
+ 
+	for (pos_type i = pos-1; i >= 0; --i) {
+		c = p.row->par()->getChar(i);
+		if (!Encodings::IsComposeChar_hebrew(c)) {
+			if (IsPrintableNonspace(c)) {
+				int const width2 = 
+					singleWidth(p.bv, p.row->par(), i, c);
+				// dalet / resh
+				dx = (c == 'ø' || c == 'ã')
+					? width2 - width 
+					: (width2 - width) / 2;
 			}
+			break;
 		}
-		++vpos;
+	}
+ 
+	// Draw nikud
+	p.pain->text(int(p.x) + dx, p.yo + p.row->baseline(), str, font);
+}
 
-		if (lyxrc.mark_foreign_language &&
-			font.language() != latex_language &&
-		    font.language() != bview->buffer()->params.language) {
-			int const y = offset + row->height() - 1;
-			pain.line(int(tmpx), y, int(x), y, LColor::language);
+ 
+void LyXText::drawArabicComposeChar(DrawRowParams & p, pos_type & vpos)
+{
+	pos_type pos = vis2log(vpos);
+	string str;
+ 
+	// first char 
+	char c = p.row->par()->getChar(pos);
+	c = transformChar(c, p.row->par(), pos);
+	str +=c;
+	++vpos;
+ 
+	LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos);
+	int const width = lyxfont::width(c, font);
+	int dx = 0;
+ 
+	for (pos_type i = pos-1; i >= 0; --i) {
+		c = p.row->par()->getChar(i);
+		if (!Encodings::IsComposeChar_arabic(c)) {
+			if (IsPrintableNonspace(c)) {
+				int const width2 = 
+					singleWidth(p.bv, p.row->par(), i, c);
+				dx = (width2 - width) / 2;
+			}
+			break;
 		}
-
-		return;
 	}
+	// Draw nikud
+	p.pain->text(int(p.x) + dx, p.yo + p.row->baseline(), str, font);
+}
+ 
+ 
+void LyXText::drawChars(DrawRowParams & p, pos_type & vpos,
+	bool hebrew, bool arabic)
+{
+	pos_type pos = vis2log(vpos);
+	pos_type const last = rowLastPrintable(p.row);
+	LyXFont const & orig_font = getFont(p.bv->buffer(), p.row->par(), pos);
+ 
+	// first character
+	string str;
+	str += p.row->par()->getChar(pos);
+	if (arabic) {
+		unsigned char c = str[0];
+		str[0] = transformChar(c, p.row->par(), pos);
+	}
+	++vpos;
 
-	// usual characters, no insets
+	// collect as much similar chars as we can
+	while (vpos <= last && (pos = vis2log(vpos)) >= 0) {
+		char c = p.row->par()->getChar(pos);
+ 
+		if (!IsPrintableNonspace(c))
+			break;
+ 
+		if (arabic && Encodings::IsComposeChar_arabic(c))
+			break;
+		if (hebrew && Encodings::IsComposeChar_hebrew(c))
+			break;
+ 
+		if (orig_font != getFont(p.bv->buffer(), p.row->par(), pos))
+			break;
+ 
+		str += c;
+		++vpos;
+	}
+ 
+	// Draw text and set the new x position
+	p.pain->text(int(p.x), p.yo + p.row->baseline(), str, orig_font);
+	p.x += lyxfont::width(str, orig_font);
+}
 
-	// Collect character that we can draw in one command
-
-	// This is dirty, but fast. Notice that it will never be too small.
-	// For the record, I'll note that Microsoft Word has a limit
-	// of 768 here. We have none :-) (Asger)
-	// Ok. I am the first to admit that the use of std::string will be
-	// a tiny bit slower than using a POD char array. However, I claim
-	// that this slowdown is so small that it is close to inperceptive.
-	// So IMHO we should go with the easier and clearer implementation.
-	// And even if 1024 is a large number here it might overflow, string
-	// will only overflow if the machine is out of memory...
-	static string textstring;
-	textstring = c;
-	++vpos;
+ 
+void LyXText::draw(DrawRowParams & p, pos_type & vpos)
+{
+	pos_type const pos = vis2log(vpos);
+	Paragraph * par = p.row->par();
 
-	pos_type const last = rowLastPrintable(row);
+	LyXFont const & orig_font = getFont(p.bv->buffer(), par, pos);
 
-	if (font.language()->lang() == "hebrew") {
-		if (Encodings::IsComposeChar_hebrew(c)) {
-			int const width = lyxfont::width(c, font2);
-			int dx = 0;
-			for (pos_type i = pos-1; i >= 0; --i) {
-				c = row->par()->getChar(i);
-				if (!Encodings::IsComposeChar_hebrew(c)) {
-					if (IsPrintableNonspace(c)) {
-						int const width2 =
-							singleWidth(bview,
-								    row->par(),
-								    i, c);
-						dx = (c == 'ø' || c == 'ã') // dalet / resh
-							? width2 - width : (width2 - width) / 2;
-					}
-					break;
-				}
-			}
-			// Draw nikud
-			pain.text(int(x) + dx, offset + row->baseline(),
-				  textstring, font);
-		} else {
-			while (vpos <= last &&
-			       (pos = vis2log(vpos)) >= 0
-			       && IsPrintableNonspace(c = row->par()->getChar(pos))
-			       && !Encodings::IsComposeChar_hebrew(c)
-			       && font2 == getFont(bview->buffer(), row->par(), pos)) {
-				textstring += c;
-				++vpos;
-			}
-			// Draw text and set the new x position
-			pain.text(int(x), offset + row->baseline(),
-				  textstring, font);
-			x += lyxfont::width(textstring, font);
-		}
-	} else if (font.language()->lang() == "arabic" &&
-		   (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
-		    lyxrc.font_norm_type == LyXRC::ISO_10646_1)) {
-		if (Encodings::IsComposeChar_arabic(c)) {
-			c = transformChar(c, row->par(), pos);
-			textstring = c;
-			int const width = lyxfont::width(c, font2);
-			int dx = 0;
-			for (pos_type i = pos-1; i >= 0; --i) {
-				c = row->par()->getChar(i);
-				if (!Encodings::IsComposeChar_arabic(c)) {
-					if (IsPrintableNonspace(c)) {
-						int const width2 =
-							singleWidth(bview,
-								    row->par(),
-								    i, c);
-						dx = (width2 - width) / 2;
-					}
-					break;
-				}
-			}
-			// Draw nikud
-			pain.text(int(x) + dx, offset + row->baseline(), 
-				  textstring, font);
-		} else {
-			textstring = transformChar(c, row->par(), pos);
-			while (vpos <= last &&
-			       (pos = vis2log(vpos)) >= 0
-			       && IsPrintableNonspace(c = row->par()->getChar(pos))
-			       && !Encodings::IsComposeChar_arabic(c)
-			       && font2 == getFont(bview->buffer(), row->par(), pos)) {
-				c = transformChar(c, row->par(), pos);
-				textstring += c;
-				++vpos;
-			}
-			// Draw text and set the new x position
-			pain.text(int(x), offset + row->baseline(),
-				  textstring, font);
-			x += lyxfont::width(textstring, font);
-		}
-	} else {
-		while (vpos <= last &&
-		       (pos = vis2log(vpos)) >= 0
-		       && IsPrintableNonspace(c = row->par()->getChar(pos))
-		       && font2 == getFont(bview->buffer(), row->par(), pos)) {
-			textstring += c;
-			++vpos;
-		}
-		// Draw text and set the new x position
-		pain.text(int(x), offset + row->baseline(), textstring, font);
-		x += lyxfont::width(textstring, font);
+	float const orig_x = p.x;
+	 
+	char const c = par->getChar(pos);
+ 
+	if (IsNewlineChar(c)) {
+		++vpos;
+		drawNewline(p, pos);
+		return;
+	} else if (IsInsetChar(c)) {
+		drawInset(p, pos);
+		++vpos;
+		drawForeignMark(p, orig_x, orig_font);
+		return;
 	}
 
+	// usual characters, no insets
+
+	// special case languages
+	bool const hebrew = (orig_font.language()->lang() == "hebrew");
+	bool const arabic = 
+		orig_font.language()->lang() == "arabic" &&
+		(lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
+		lyxrc.font_norm_type == LyXRC::ISO_10646_1);
+
+	// draw as many chars as we can
+	if ((!hebrew && !arabic)
+		|| (hebrew && !Encodings::IsComposeChar_hebrew(c))
+		|| (arabic && !Encodings::IsComposeChar_arabic(c))) {
+		drawChars(p, vpos, true, false);
+	} else if (hebrew) {
+		drawHebrewComposeChar(p, vpos);
+	} else if (arabic) {
+		drawArabicComposeChar(p, vpos);
+	}
+
+	drawForeignMark(p, orig_x, orig_font);
+ 
 #ifdef INHERIT_LANGUAGE
 #ifdef WITH_WARNINGS
 	if ((font.language() == inherit_language) ||
@@ -620,17 +654,6 @@ void LyXText::draw(BufferView * bview, Row const * row,
 		lyxerr << "No this shouldn't happen!\n";
 #endif
 #endif
-	if (lyxrc.mark_foreign_language &&
-	    font.language() != latex_language &&
-	    font.language() != bview->buffer()->params.language) {
-		int const y = offset + row->height() - 1;
-		pain.line(int(tmpx), y, int(x), y,
-			  LColor::language);
-	}
-
-	// If we want ulem.sty support, drawing
-	// routines should go here. (Asger)
-	// Why shouldn't LyXFont::drawText handle it internally?
 }
 
 
@@ -1039,13 +1062,6 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const
 	}
 	
 	int const fill = paper_width - w - rightMargin(bview->buffer(), row);
-#ifdef WITH_WARNINGS
-#warning Please fix me (Jug!)
-#endif
-#if 0
-	if (fill < 0)
-		return 0;
-#endif
 	return fill;
 }
 
@@ -1111,7 +1127,7 @@ int LyXText::numberOfHfills(Buffer const * buf, Row const * row) const
 	pos_type first = row->pos();
 	if (first) { /* hfill *DO* count at the beginning 
 		      * of paragraphs! */
-		while(first <= last && row->par()->isHfill(first))
+		while (first <= last && row->par()->isHfill(first))
 			++first;
 	}
 
@@ -1134,7 +1150,7 @@ int LyXText::numberOfLabelHfills(Buffer const * buf, Row const * row) const
 	pos_type first = row->pos();
 	if (first) { /* hfill *DO* count at the beginning 
 		      * of paragraphs! */
-		while(first < last && row->par()->isHfill(first))
+		while (first < last && row->par()->isHfill(first))
 			++first;
 	}
 
@@ -1160,8 +1176,16 @@ bool LyXText::hfillExpansion(Buffer const * buf, Row const * row_ptr,
 		return false;
 	
 	// at the end of a row it does not count
-	if (pos >= rowLast(row_ptr))
-		return false;
+	// unless another hfill exists on the line
+	if (pos >= rowLast(row_ptr)) {
+		pos_type i = row_ptr->pos();
+		while (i < pos && !row_ptr->par()->isHfill(i)) {
+			++i;
+		}
+		if (i == pos) {
+			return false;
+		}
+	} 
 	
 	// at the beginning of a row it does not count, if it is not 
 	// the first row of a paragaph
@@ -1318,9 +1342,8 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const
 			maxasc += LYX_PAPER_MARGIN;
       
 		// add the vertical spaces, that the user added
-		if (firstpar->params().spaceTop().kind() != VSpace::NONE)
-			maxasc += int(firstpar->params().spaceTop().inPixels(bview));
-      
+		maxasc += getLengthMarkerHeight(bview, firstpar->params().spaceTop());
+ 
 		// do not forget the DTP-lines!
 		// there height depends on the font of the nearest character
 		if (firstpar->params().lineTop())
@@ -1432,8 +1455,7 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const
 			maxdesc += LYX_PAPER_MARGIN;
 	  
 		// add the vertical spaces, that the user added
-		if (firstpar->params().spaceBottom().kind() != VSpace::NONE)
-			maxdesc += int(firstpar->params().spaceBottom().inPixels(bview));
+		maxdesc += getLengthMarkerHeight(bview, firstpar->params().spaceBottom());
 	  
 		// do not forget the DTP-lines!
 		// there height depends on the font of the nearest character
@@ -1502,7 +1524,7 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const
 	if (inset_owner) {
 		Row * r = firstrow;
 		width = max(0,workWidth(bview));
-		while(r) {
+		while (r) {
 			if (r->width() > width)
 				width = r->width();
 			r = r->next();
@@ -1515,35 +1537,34 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const
  * start at the implicit given position */
 void LyXText::appendParagraph(BufferView * bview, Row * row) const
 {
-   bool not_ready = true;
+	bool not_ready = true;
    
-   // The last character position of a paragraph is an invariant so we can 
-   // safely get it here. (Asger)
-   pos_type const lastposition = row->par()->size();
-   do {
-      // Get the next breakpoint
-      pos_type z = nextBreakPoint(bview, row, workWidth(bview));
+	// The last character position of a paragraph is an invariant so we can 
+	// safely get it here. (Asger)
+	pos_type const lastposition = row->par()->size();
+	do {
+		// Get the next breakpoint
+		pos_type z = nextBreakPoint(bview, row, workWidth(bview));
       
-      Row * tmprow = row;
+		Row * tmprow = row;
 
-      // Insert the new row
-      if (z < lastposition) {
-	 ++z;
-	 insertRow(row, row->par(), z);
-	 row = row->next();
+		// Insert the new row
+		if (z < lastposition) {
+			++z;
+			insertRow(row, row->par(), z);
+			row = row->next();
 
-	 row->height(0);
-      } else
-	 not_ready = false;
+			row->height(0);
+		} else
+			not_ready = false;
       
-      // Set the dimensions of the row
-#ifdef WITH_WARNINGS
-#warning Something is rotten here! (Jug)
-#endif
-      tmprow->fill(fill(bview, tmprow, workWidth(bview)));
-      setHeightOfRow(bview, tmprow);
+		// Set the dimensions of the row
+		// fixed fill setting now by calling inset->update() in
+		// SingleWidth when needed!
+		tmprow->fill(fill(bview, tmprow, workWidth(bview)));
+		setHeightOfRow(bview, tmprow);
 
-   } while (not_ready);
+	} while (not_ready);
 }
 
 
@@ -1857,11 +1878,13 @@ void LyXText::insertChar(BufferView * bview, char c)
 	}
    
 	// the display inset stuff
-	if (cursor.row()->par()->isInset(cursor.row()->pos())
-	    && cursor.row()->par()->getInset(cursor.row()->pos())
-	    && (cursor.row()->par()->getInset(cursor.row()->pos())->display() ||
-		cursor.row()->par()->getInset(cursor.row()->pos())->needFullRow()))
-		cursor.row()->fill(-1); // to force a new break  
+	if (cursor.row()->par()->isInset(cursor.row()->pos())) {
+		Inset * inset = cursor.row()->par()->getInset(cursor.row()->pos());
+		if (inset && (inset->display() || inset->needFullRow())) { 
+			// force a new break
+			cursor.row()->fill(-1); // to force a new break  
+		}
+	}
 
 	// get the cursor row fist
 	Row * row = cursor.row();
@@ -3133,6 +3156,80 @@ void LyXText::paintRowDepthBar(DrawRowParams & p)
 	}
 }
 
+
+int LyXText::getLengthMarkerHeight(BufferView * bv, VSpace const & vsp) const
+{
+	if (vsp.kind() != VSpace::LENGTH) {
+		return int(vsp.inPixels(bv));
+	}
+
+	int const space_size = int(vsp.inPixels(bv));
+	int const arrow_size = 10;
+ 
+	LyXFont font;
+	font.decSize();
+	int const min_size = 2 * arrow_size + 10
+		+ lyxfont::maxAscent(font)
+		+ lyxfont::maxDescent(font);
+
+	return std::max(min_size, space_size);
+}
+
+ 
+int LyXText::drawLengthMarker(DrawRowParams & p, string const & prefix,
+	VSpace const & vsp, int start)
+{
+	string const str(prefix
+		+ " (" + vsp.asLyXCommand() + ")");
+ 
+	int const arrow_size = 10;
+ 
+	int const size = getLengthMarkerHeight(p.bv, vsp);
+ 
+	// first the string
+	int w = 0;
+	int a = 0;
+	int d = 0;
+ 
+	LyXFont font;
+	font.setColor(LColor::added_space).decSize();
+	lyxfont::rectText(str, font, w, a, d);
+ 
+	int const end = start + size;
+
+	p.pain->rectText(p.xo + 2 * arrow_size + 5, 
+		start + ((end - start) / 2) + d,
+		str, font,
+		backgroundColor(),
+		backgroundColor());
+ 
+	// adding or removing space
+	bool const added = !(vsp.length().len().value() < 0.0);
+
+	int const leftx = p.xo;
+	int const midx = leftx + arrow_size;
+	int const rightx = midx + arrow_size;
+ 
+	// top arrow
+	int const ty1 = added ? (start + arrow_size) : start;
+	int const ty2 = added ? start : (start + arrow_size);
+
+	p.pain->line(leftx, ty1, midx, ty2, LColor::added_space);
+	p.pain->line(midx, ty2, rightx, ty1, LColor::added_space);
+
+	// bottom arrow
+	int const by1 = added ? (end - arrow_size) : end;
+	int const by2 = added ? end : (end - arrow_size);
+ 
+	p.pain->line(leftx, by1, midx, by2, LColor::added_space);
+	p.pain->line(midx, by2, rightx, by1, LColor::added_space);
+
+	// joining line
+	p.pain->line(midx, ty2, midx, by2, LColor::added_space);
+
+	return size;
+}
+ 
  
 void LyXText::paintFirstRow(DrawRowParams & p)
 {
@@ -3145,7 +3242,7 @@ void LyXText::paintFirstRow(DrawRowParams & p)
 	}
 	
 	int y_top = 0;
-		
+
 	// think about the margins
 	if (!p.row->previous() && bv_owner)
 		y_top += LYX_PAPER_MARGIN;
@@ -3184,36 +3281,14 @@ void LyXText::paintFirstRow(DrawRowParams & p)
 		p.pain->line(x, y2, x, y1, LColor::added_space);
 		
 		y_top += 3 * defaultHeight();
+		y_top += int(parparams.spaceTop().inPixels(p.bv));
 	} else if (parparams.spaceTop().kind() == VSpace::LENGTH) {
-		string str = string(_("Space above")) + " ("
-			+ parparams.spaceTop().asLyXCommand()
-			+ ")";
- 
-		int const space = int(parparams.spaceTop().inPixels(p.bv));
-		int const y = p.yo + y_top + space / 2;
- 
-		p.pain->line(p.xo, y, p.xo + p.width, y, 
-			LColor::added_space, Painter::line_onoffdash);
- 
-		int w = 0;
-		int a = 0;
-		int d = 0;
- 
-		LyXFont pb_font;
-		pb_font.setColor(LColor::added_space).decSize();
-		lyxfont::rectText(str, pb_font, w, a, d);
-
-		// don't draw if it won't fit 
-		if (a + d + 4 < space) { 
-			p.pain->rectText(p.xo + (p.width - w)/2, y + d,
-				      str, pb_font,
-				      backgroundColor(),
-				      backgroundColor());
-		}
+		y_top += drawLengthMarker(p, _("Space above"),
+			parparams.spaceTop(), p.yo + y_top);
+	} else {
+		y_top += int(parparams.spaceTop().inPixels(p.bv));
 	}
 	
-	y_top += int(parparams.spaceTop().inPixels(p.bv));
-	
 	Buffer const * buffer = p.bv->buffer();
  
 	LyXLayout const & layout =
@@ -3291,7 +3366,7 @@ void LyXText::paintFirstRow(DrawRowParams & p)
 							lyxfont::width(str, font);
 					}
  
-					p.pain->text(int(x), p.yo +
+					p.pain->text(int(x),
 						p.yo + p.row->baseline() - 
 						p.row->ascent_of_text() - maxdesc,
 						str, font);
@@ -3300,9 +3375,10 @@ void LyXText::paintFirstRow(DrawRowParams & p)
 				if (is_rtl) {
 					x = ww - leftMargin(p.bv, p.row)
 						+ lyxfont::width(layout.labelsep, font);
-				} else
+				} else {
 					x = p.x - lyxfont::width(layout.labelsep, font)
 						- lyxfont::width(str, font);
+				}
 
 				p.pain->text(int(x), p.yo + p.row->baseline(), str, font);
 			}
@@ -3400,38 +3476,17 @@ void LyXText::paintLastRow(DrawRowParams & p)
 		p.pain->line(x, y, x, y2, LColor::added_space);
  
 		y_bottom -= 3 * defaultHeight();
+		y_bottom -= int(parparams.spaceBottom().inPixels(p.bv));
 	} else if (parparams.spaceBottom().kind() == VSpace::LENGTH) {
-		string str = string(_("Space below"))
-			+ " ("
-			+ parparams.spaceBottom().asLyXCommand()
-			+ ")";
- 
-		int const space = int(parparams.spaceBottom().inPixels(p.bv));
-		int const y = p.yo + y_bottom - space / 2;
+		int const height =  getLengthMarkerHeight(p.bv, parparams.spaceBottom());
+		y_bottom -= drawLengthMarker(p, _("Space below"),
+				parparams.spaceBottom(),
+				p.yo + y_bottom - height);
  
-		p.pain->line(p.xo, y, p.xo + p.width, y,
-			LColor::added_space, Painter::line_onoffdash);
- 
-		int w = 0;
-		int a = 0;
-		int d = 0;
- 
-		LyXFont pb_font;
-		pb_font.setColor(LColor::added_space).decSize();
-		lyxfont::rectText(str, pb_font, w, a, d);
-
-		// don't draw if it won't fit 
-		if (a + d + 4 < space) { 
-			p.pain->rectText(p.xo + (p.width - w) / 2, y + d,
-				      str, pb_font,
-				      backgroundColor(),
-				      backgroundColor());
-		} 
+	} else {
+		y_bottom -= int(parparams.spaceBottom().inPixels(p.bv));
 	}
 	
-	// think about user added space
-	y_bottom -= int(parparams.spaceBottom().inPixels(p.bv));
-	
 	Buffer const * buffer = p.bv->buffer();
  
 	// draw a bottom line
@@ -3562,7 +3617,7 @@ void LyXText::paintRowText(DrawRowParams & p)
 				p.x += p.separator;
 			++vpos;
 		} else {
-			draw(p.bv, p.row, vpos, p.yo, p.x, p.cleared);
+			draw(p, vpos);
 		}
 	}
 }