X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fvspace.C;h=a314e312543f6d74e3cf4a839ec072eecf27a33b;hb=32ef0d04c48a1751abbb5e3b17d1bec25f22c255;hp=c66e7874f3a46c73fbaefdabc2edab49edb62bec;hpb=27de1486ca34aaad446adb798d71a77d6f6304da;p=lyx.git

diff --git a/src/vspace.C b/src/vspace.C
index c66e7874f3..a314e31254 100644
--- a/src/vspace.C
+++ b/src/vspace.C
@@ -1,13 +1,12 @@
-// -*- C++ -*-
 /* This file is part of
- * ======================================================
+ * ====================================================== 
  * 
  *           LyX, The Document Processor
  * 	 
- *	    Copyright (C) 1995 Matthias Ettrich
- *          Copyright (C) 1995-1998 The LyX Team.
+ *           Copyright 1995 Matthias Ettrich
+ *           Copyright 1995-2001 The LyX Team.
  *
- *======================================================*/
+ * ====================================================== */
 
 #include <config.h>
 
@@ -15,142 +14,173 @@
 #pragma implementation "vspace.h"
 #endif
 
+#include <stdio.h>
+
 #include "lyx_main.h"
 #include "buffer.h"
 #include "vspace.h"
 #include "lyxrc.h"
 #include "lyxtext.h"
-#include <stdio.h>
-#include <string.h>
 #include "BufferView.h"
+#include "support/lstrings.h"
 
-extern LyXRC * lyxrc;
-extern BufferView *current_view;
 
-// 	$Id: vspace.C,v 1.1 1999/09/27 18:44:38 larsbj Exp $	
-
-#if !defined(lint) && !defined(WITH_WARNINGS)
-static char vcid[] = "$Id: vspace.C,v 1.1 1999/09/27 18:44:38 larsbj Exp $";
-#endif /* lint */
+namespace {
 
 /*  length units
  */
 
-static const int   num_units            = int(LyXLength::UNIT_NONE);
+int const num_units = LyXLength::UNIT_NONE;
 
 // I am not sure if "mu" should be possible to select (Lgb)
-static char const* unit_name[num_units] = { "sp", "pt", "bp", "dd",
-					    "mm", "pc", "cc", "cm",
-					    "in", "ex", "em", "mu" }; 
+char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
+				      "mm", "pc", "cc", "cm",
+				      "in", "ex", "em", "mu",
+				      "%",  "c%", "p%", "l%" }; 
 
 
-LyXLength::UNIT unitFromString (LString const & data)
-{
-	int i=0;
-	while ((i<num_units) && (data != unit_name[i])) i++;
-	return (LyXLength::UNIT)i;
-}
-
 /*  The following static items form a simple scanner for
  *  length strings, used by isValid[Glue]Length.  See comments there.
  */
-static float           number[4] = { 0, 0, 0, 0 };
-static LyXLength::UNIT unit[4]   = { LyXLength::UNIT_NONE,
-				     LyXLength::UNIT_NONE,
-				     LyXLength::UNIT_NONE,
-				     LyXLength::UNIT_NONE };
-//static int number_index, unit_index;
-int number_index, unit_index;
-
-static void advance (LString& data, const int n)
+float           number[4] = { 0, 0, 0, 0 };
+LyXLength::UNIT unit[4]   = { LyXLength::UNIT_NONE,
+			      LyXLength::UNIT_NONE,
+			      LyXLength::UNIT_NONE,
+			      LyXLength::UNIT_NONE };
+int number_index;
+int unit_index;
+
+
+inline
+void lyx_advance(string & data, unsigned int n)
 {
-	if (data.length() <= n)
-		data.clean();
-	else
-		data.substring (n, data.length()-1);
+	data.erase(0, n);
 }
 
-static bool isEndOfData (LString& data)
+
+inline
+bool isEndOfData(string const & data)
 {
-	data.frontStrip (' ');
-	return data.empty();
+	return frontStrip(data).empty();
 }
 
-static char nextToken (LString& data)
-{
-	data.frontStrip (' ');
 
+char nextToken(string & data)
+{
+	data = frontStrip(data);
 	if (data.empty())
 		return '\0';
 	else if (data[0] == '+') {
-		advance (data, 1);
+		lyx_advance(data, 1);
 		return '+';
-	}
-	else if (data.prefixIs ("plus")) {
-		advance (data, 4);
+	} else if (prefixIs(data, "plus")) {
+		lyx_advance(data, 4);
 		return '+';
-	}
-	else if (data[0] == '-') {
-		advance (data, 1);
+	} else if (data[0] == '-') {
+		lyx_advance(data, 1);
 		return '-';
-	}
-        else if (data.prefixIs ("minus")) {
-		advance (data, 5);
+	} else if (prefixIs(data, "minus")) {
+		lyx_advance(data, 5);
 		return '-';
-	}
-	else {
-		int      i;
-
-		// I really mean assignment ("=") below, not equality!
-
-		if ((i = strspn (data.c_str(), "0123456789."))) {
-			if (number_index > 3) return 'E';  // Error
-                        LString buffer = data;
-			buffer.substring (0, i-1);
-			if (sscanf (buffer.c_str(),
-				    "%f", &number[number_index]) == 1) {
-				advance (data, i);
-				number_index++;
+	} else {
+		string::size_type i = data.find_first_not_of("0123456789.");
+
+		if (i != 0) {
+			if (number_index > 3) return 'E';
+
+			string buffer;
+		
+			// we have found some number
+			if (i == string::npos) {
+				buffer = data;
+				i = data.size() + 1;
+			} else
+				buffer = data.substr(0, i);
+
+			lyx_advance(data, i);
+
+			if (isStrDbl(buffer)) {
+				number[number_index] = strToDbl(buffer);
+				++number_index;
 				return 'n';
-			} else 
-				return 'E';  // Error
-		} else if ((i = strspn (data.c_str(),
-				       "abcdefghijklmnopqrstuvwxyz"))) {
-			if (unit_index > 3) return 'E';  // Error
-			LString buffer = data; buffer.substring (0, i-1);
-			unit[unit_index] = unitFromString (buffer);
+			} else return 'E';
+		}
+		
+		i = data.find_first_not_of("abcdefghijklmnopqrstuvwxyz%");
+		if (i != 0) {
+			if (unit_index > 3) return 'E';
+
+			string buffer;
+		
+			// we have found some alphabetical string
+			if (i == string::npos) {
+				buffer = data;
+				i = data.size() + 1;
+			} else
+				buffer = data.substr(0, i);
+
+			// possibly we have "mmplus" string or similar
+			if (buffer.size() > 5 && (buffer.substr(2,4) == string("plus") || buffer.substr(2,5) == string("minus"))) {
+				lyx_advance(data, 2);
+				unit[unit_index] = unitFromString(buffer.substr(0, 2));
+			} else {
+				lyx_advance(data, i);
+				unit[unit_index] = unitFromString(buffer);
+			}
+
 			if (unit[unit_index] != LyXLength::UNIT_NONE) {
-				advance (data, i);
-				unit_index++;
+				++unit_index;
 				return 'u';
-			} else
-				return 'E';  // Error
-		} else
-			return 'E';  // Error
+			} else return 'E';  // Error
+		}
+		return 'E';  // Error
 	}
 }
 
-static struct {
-	char const* pattern;
+
+struct LaTeXLength {
+	char const * pattern;
 	int   plus_val_index, minus_val_index,
-	      plus_uni_index, minus_uni_index;
-} table[] = { { "nu",       0, 0, 0, 0 },
-	      { "nu+nu",    2, 0, 2, 0 },
-	      { "nu+nu-nu", 2, 3, 2, 3 },
-	      { "nu+-nu",   2, 2, 2, 2 },
-	      { "nu-nu",    0, 2, 0, 2 },
-	      { "nu-nu+nu", 3, 2, 3, 2 },
-	      { "nu-+nu",   2, 2, 2, 2 },
-	      { "n+nu",     2, 0, 1, 0 },
-	      { "n+n-nu",   2, 3, 1, 1 },
-	      { "n+-nu",    2, 2, 1, 1 },
-	      { "n-nu",     0, 2, 0, 1 },
-	      { "n-n+nu",   3, 2, 1, 1 },
-	      { "n-+nu",    2, 2, 1, 1 },
-              { "",         0, 0, 0, 0 }   // sentinel, must be empty
+		plus_uni_index, minus_uni_index;
 };
 
-bool isValidGlueLength (LString const & data, LyXGlueLength* result)
+
+LaTeXLength table[] = {
+	{ "nu",       0, 0, 0, 0 },
+	{ "nu+nu",    2, 0, 2, 0 },
+	{ "nu+nu-nu", 2, 3, 2, 3 },
+	{ "nu+-nu",   2, 2, 2, 2 },
+	{ "nu-nu",    0, 2, 0, 2 },
+	{ "nu-nu+nu", 3, 2, 3, 2 },
+	{ "nu-+nu",   2, 2, 2, 2 },
+	{ "n+nu",     2, 0, 1, 0 },
+	{ "n+n-nu",   2, 3, 1, 1 },
+	{ "n+-nu",    2, 2, 1, 1 },
+	{ "n-nu",     0, 2, 0, 1 },
+	{ "n-n+nu",   3, 2, 1, 1 },
+	{ "n-+nu",    2, 2, 1, 1 },
+	{ "",         0, 0, 0, 0 }   // sentinel, must be empty
+};
+
+} // namespace anon
+
+const char * stringFromUnit(int unit)
+{
+    if (unit < 0 || unit >= num_units)
+	return 0;
+    return unit_name[unit];
+}
+
+
+LyXLength::UNIT unitFromString (string const & data)
+{
+	int i = 0;
+	while ((i < num_units) && (data != unit_name[i])) ++i;
+	return static_cast<LyXLength::UNIT>(i);
+}
+
+
+bool isValidGlueLength (string const & data, LyXGlueLength * result)
 {
 	// This parser is table-driven.  First, it constructs a "pattern"
         // that describes the sequence of tokens in "data".  For example,
@@ -168,19 +198,20 @@ bool isValidGlueLength (LString const & data, LyXGlueLength* result)
         // forward approach leads to very long, tedious code that would be
         // much harder to understand and maintain. (AS)
 
-	LString   buffer = data;
-	buffer.frontStrip(' ');
+	if (data.empty())
+		return true;
+	string buffer = frontStrip(data);
 
 	// To make isValidGlueLength recognize negative values as
 	// the first number this little hack is needed:
 	short val_sign = 1; // positive as default
-	switch(buffer[0]) {
+	switch (buffer[0]) {
 	case '-':
-		advance(buffer, 1);
+		lyx_advance(buffer, 1);
 		val_sign = -1;
 		break;
 	case '+':
-		advance(buffer, 1);
+		lyx_advance(buffer, 1);
 		// fall through
 	default:
 		// no action
@@ -198,14 +229,14 @@ bool isValidGlueLength (LString const & data, LyXGlueLength* result)
 		if (pattern_index > 20) return false;
 		pattern[pattern_index] = nextToken (buffer);
 		if (pattern[pattern_index] == 'E') return false;
-		pattern_index++;
+		++pattern_index;
 	}
 	pattern[pattern_index] = '\0';
 
 	// search "pattern" in "table"
 	table_index = 0;
-	while (strcmp (pattern, table[table_index].pattern)) {
-		table_index++;
+	while (compare(pattern, table[table_index].pattern)) {
+		++table_index;
 		if (!*table[table_index].pattern) return false;
 	}
 	
@@ -213,38 +244,40 @@ bool isValidGlueLength (LString const & data, LyXGlueLength* result)
 	// is zero, the corresponding array value is zero or UNIT_NONE,
 	// so we needn't check this.
 	if (result) {
-	    result->val = number[1] * val_sign;
-	    result->uni = unit[1];
-	    result->plus_val  = number[table[table_index].plus_val_index];
-	    result->minus_val = number[table[table_index].minus_val_index];
-	    result->plus_uni  = unit  [table[table_index].plus_uni_index];
-	    result->minus_uni = unit  [table[table_index].minus_uni_index];
+		result->val = number[1] * val_sign;
+		result->uni = unit[1];
+		result->plus_val  = number[table[table_index].plus_val_index];
+		result->minus_val = number[table[table_index].minus_val_index];
+		result->plus_uni  = unit  [table[table_index].plus_uni_index];
+		result->minus_uni = unit  [table[table_index].minus_uni_index];
 	}
 	return true;
 }
 
 
-bool isValidLength(LString const & data, LyXLength* result)
+bool isValidLength(string const & data, LyXLength * result)
 {
 	/// This is a trimmed down version of isValidGlueLength.
 	/// The parser may seem overkill for lengths without 
 	/// glue, but since we already have it, using it is
 	/// easier than writing something from scratch.
+	if (data.empty())
+		return true;
 
-        LString   buffer = data;
+        string   buffer(data);
 	int       pattern_index = 0;
 	char      pattern[3];
 
 	// To make isValidLength recognize negative values
 	// this little hack is needed:
 	short val_sign = 1; // positive as default
-	switch(buffer[0]) {
+	switch (buffer[0]) {
 	case '-':
-		advance(buffer, 1);
+		lyx_advance(buffer, 1);
 		val_sign = -1;
 		break;
 	case '+':
-		advance(buffer, 1);
+		lyx_advance(buffer, 1);
 		// fall through
 	default:
 		// no action
@@ -259,25 +292,26 @@ bool isValidLength(LString const & data, LyXLength* result)
 		if (pattern_index > 2) return false;
 		pattern[pattern_index] = nextToken (buffer);
 		if (pattern[pattern_index] == 'E') return false;
-		pattern_index++;
+		++pattern_index;
 	}
 	pattern[pattern_index] = '\0';
 
 	// only the most basic pattern is accepted here
-	if (strcmp (pattern, "nu") != 0) return false;		
+	if (compare(pattern, "nu") != 0) return false;		
 	
 	// It _was_ a correct length string.  
 	// Store away the values we found.
 	if (result) {
-	    result->val = number[1]*val_sign;
-	    result->uni = unit[1];
+		result->val = number[1] * val_sign;
+		result->uni = unit[1];
 	}
 	return true;
 }
 
+
 /// LyXLength class
 
-LyXLength::LyXLength(LString const & data)
+LyXLength::LyXLength(string const & data)
 {
 	LyXLength tmp;
 	
@@ -289,151 +323,165 @@ LyXLength::LyXLength(LString const & data)
 	}
 }
 
-bool LyXLength::operator== (LyXLength other)
+
+string const LyXLength::asString() const
 {
-	return (this->val == other.val)
-	    && (this->uni == other.uni);
+	ostringstream buffer;
+	buffer << val << unit_name[uni]; // setw?
+	return buffer.str().c_str();
 }
 
-LString LyXLength::asString() const
-{
-	char buffer[20];
 
-	sprintf (buffer, "%g%s", val, unit_name[uni]);
-	return LString (buffer);
+string const LyXLength::asLatexString() const
+{
+	ostringstream buffer;
+	switch(uni) {
+	case PW:
+	case PE:
+	    buffer << abs(static_cast<int>(val/100)) << "." << abs(static_cast<int>(val)%100) << "\\columnwidth";
+	    break;
+	case PP:
+	    buffer << "." << abs(static_cast<int>(val/100)) << "." << abs(static_cast<int>(val)%100) << "\\pagewidth";
+	    break;
+	case PL:
+	    buffer << "." << abs(static_cast<int>(val/100)) << "." << abs(static_cast<int>(val)%100) << "\\linewidth";
+	    break;
+	default:
+	    buffer << val << unit_name[uni]; // setw?
+	    break;
+	}
+	return buffer.str().c_str();
 }
 
 
 /*  LyXGlueLength class
  */
 
-LyXGlueLength::LyXGlueLength (LString const & data)
+LyXGlueLength::LyXGlueLength (string const & data)
 {
 	LyXGlueLength tmp(0.0, PT);
 
 	if (!isValidGlueLength (data, &tmp))
 		return; // should raise an exception
 	else {
-		val=tmp.val;
-		uni=tmp.uni;
-		plus_val =tmp.plus_val;
-		plus_uni =tmp.plus_uni;
-		minus_val=tmp.minus_val;
-		minus_uni=tmp.minus_uni;
+		val = tmp.val;
+		uni = tmp.uni;
+		plus_val = tmp.plus_val;
+		plus_uni = tmp.plus_uni;
+		minus_val = tmp.minus_val;
+		minus_uni = tmp.minus_uni;
 	}
 }
 
 
-bool LyXGlueLength::operator== (LyXGlueLength other)
+string const LyXGlueLength::asString() const
 {
-	return (this->val == other.val) 
-	    && (this->uni == other.uni)
-	    && (this->plus_val  == other.plus_val)
-	    && (this->plus_uni  == other.plus_uni)
-	    && (this->minus_val == other.minus_val)
-	    && (this->minus_uni == other.minus_uni);
-}
+	ostringstream buffer;
 
-
-LString LyXGlueLength::asString () const
-{
-	char buffer[20];
-	
 	if (plus_val != 0.0)
-	    if (minus_val != 0.0)
-		if ((uni == plus_uni) && (uni == minus_uni))
-		    if (plus_val == minus_val)
-			sprintf (buffer, "%g+-%g%s",
-				 val, plus_val, unit_name[uni]);
-		    else
-			sprintf (buffer, "%g+%g-%g%s",
-				 val, plus_val, minus_val, 
-				 unit_name[uni]);
-		else
-		    if ((plus_uni == minus_uni) && (plus_val == minus_val))
-			sprintf (buffer, "%g%s+-%g%s",
-				 val, unit_name[uni],
-				 plus_val, unit_name[plus_uni]);
-		    else
-			sprintf (buffer, "%g%s+%g%s-%g%s",
-				 val,       unit_name[uni],
-				 plus_val,  unit_name[plus_uni],
-				 minus_val, unit_name[minus_uni]);
-	    else 
-		if (uni == plus_uni)
-		    sprintf (buffer, "%g+%g%s",
-			     val, plus_val, unit_name[uni]);
-		else
-		    sprintf (buffer, "%g%s+%g%s",
-			     val,      unit_name[uni],
-			     plus_val, unit_name[plus_uni]);
+		if (minus_val != 0.0)
+			if ((uni == plus_uni) && (uni == minus_uni))
+				if (plus_val == minus_val)
+					buffer << val << "+-"
+					       << plus_val << unit_name[uni];
+				else
+					buffer << val
+					       << '+' << plus_val
+					       << '-' << minus_val
+					       << unit_name[uni];
+			else
+				if (plus_uni == minus_uni
+				    && plus_val == minus_val)
+					buffer << val << unit_name[uni]
+					       << "+-" << plus_val
+					       << unit_name[plus_uni];
+	
+				else
+					buffer << val << unit_name[uni]
+					       << '+' << plus_val
+					       << unit_name[plus_uni]
+					       << '-' << minus_val
+					       << unit_name[minus_uni];
+		else 
+			if (uni == plus_uni)
+				buffer << val << '+' << plus_val
+				       << unit_name[uni];
+			else
+				buffer << val << unit_name[uni]
+				       << '+' << plus_val
+				       << unit_name[plus_uni];
+	
 	else
-	    if (minus_val != 0.0)
-		if (uni == minus_uni)
-		    sprintf (buffer, "%g-%g%s",
-			     val, minus_val, unit_name[uni]);
+		if (minus_val != 0.0)
+			if (uni == minus_uni)
+				buffer << val << '-' << minus_val
+				       << unit_name[uni];
+	
+			else
+				buffer << val << unit_name[uni]
+				       << '-' << minus_val
+				       << unit_name[minus_uni];
 		else
-		    sprintf (buffer, "%g%s-%g%s",
-			     val,       unit_name[uni],
-			     minus_val, unit_name[minus_uni]);
-	    else
-		sprintf (buffer, "%g%s", val, unit_name[uni]);
-	return LString (buffer);
+			buffer << val << unit_name[uni];
+
+	return buffer.str().c_str();
 }
 
 
-LString LyXGlueLength::asLatexString() const
+string const LyXGlueLength::asLatexString() const
 {
-	char buffer[40];
+	ostringstream buffer;
 
 	if (plus_val != 0.0)
 		if (minus_val != 0.0)
-			sprintf (buffer, "%g%s plus %g%s minus %g%s",
-				 val, unit_name[uni],
-				 plus_val,  unit_name[plus_uni],
-				 minus_val, unit_name[minus_uni]);
+			buffer << val << unit_name[uni]
+			       << " plus "
+			       << plus_val << unit_name[plus_uni]
+			       << " minus "
+			       << minus_val << unit_name[minus_uni];
 		else
-			sprintf (buffer, "%g%s plus %g%s",
-				 val,      unit_name[uni],
-				 plus_val, unit_name[plus_uni]);
+			buffer << val << unit_name[uni]
+			       << " plus "
+			       << plus_val << unit_name[plus_uni];
 	else
 		if (minus_val != 0.0)
-			sprintf (buffer, "%g%s minus %g%s",
-				 val,       unit_name[uni],
-				 minus_val, unit_name[minus_uni]);
+			buffer << val << unit_name[uni]
+			       << " minus "
+			       << minus_val << unit_name[minus_uni];
 		else
-			sprintf (buffer, "%g%s",
-				 val, unit_name[uni]);
-	return LString (buffer);
+			buffer << val << unit_name[uni];
+
+	return buffer.str().c_str();
 }
 
 
 /*  VSpace class
  */
 
-VSpace::VSpace (LString const & data)
+VSpace::VSpace (string const & data)
 	: kin (NONE), len (0.0, LyXLength::PT) 
 {
+	kp = false;
+	if (data.empty())
+		return;
 	float   value;
-	LString input  = data;
+	string input  = strip(data);
 
-	input.strip(' ');
 	int length = input.length();
 
 	if (length > 1 && input[length-1] == '*') {
 		kp = true;
-		input.substring (0, length-2);
-	} else
-		kp = false;
-
-	if      (input.prefixIs ("defskip"))   kin = DEFSKIP;
-	else if (input.prefixIs ("smallskip")) kin = SMALLSKIP;
-	else if (input.prefixIs ("medskip"))   kin = MEDSKIP;
-	else if (input.prefixIs ("bigskip"))   kin = BIGSKIP;
-	else if (input.prefixIs ("vfill"))     kin = VFILL;
+		input.erase(length - 1);
+	}
+
+	if      (prefixIs (input, "defskip"))   kin = DEFSKIP;
+	else if (prefixIs (input, "smallskip")) kin = SMALLSKIP;
+	else if (prefixIs (input, "medskip"))   kin = MEDSKIP;
+	else if (prefixIs (input, "bigskip"))   kin = BIGSKIP;
+	else if (prefixIs (input, "vfill"))     kin = VFILL;
 	else if (isValidGlueLength (input, &len))
 		kin = LENGTH;
-	else if (sscanf (input.c_str(), "%f", &value) == 1) {
+	else if (sscanf(input.c_str(), "%f", &value) == 1) {
 		// This last one is for reading old .lyx files
 		// without units in added_space_top/bottom.
 		// Let unit default to centimeters here.
@@ -443,24 +491,24 @@ VSpace::VSpace (LString const & data)
 }
 
 
-bool VSpace::operator== (VSpace other)
+bool VSpace::operator==(VSpace const & other) const
 {
-	if (this->kin == other.kin) 
-		if (this->kin == LENGTH)
-			if (this->len == other.len)
-				return this->kp == other.kp;
-			else
-				return false;
-		else
-			return this->kp == other.kp;
-	else
+	if (this->kin != other.kin)
+		return false;
+ 
+	if (this->kin != LENGTH)
+		return this->kp == other.kp;
+ 
+	if (!(this->len == other.len))
 		return false;
+ 
+	return this->kp == other.kp;
 }
 
 
-LString VSpace::asLyXCommand() const
+string const VSpace::asLyXCommand() const
 {
-        LString result;
+        string result;
 
 	switch (kin) {
 	case NONE:      break;
@@ -478,37 +526,50 @@ LString VSpace::asLyXCommand() const
 }
 
 
-LString VSpace::asLatexCommand() const
+string const VSpace::asLatexCommand(BufferParams const & params) const
 {
 	switch (kin) {
-	case NONE:      return LString();
+	case NONE:      return string();
 	case DEFSKIP:   
-	  return current_view->currentBuffer()->params.getDefSkip().asLatexCommand();
+		return params.getDefSkip().asLatexCommand(params);
 	case SMALLSKIP: return kp ? "\\vspace*{\\smallskipamount}"
-				  : "\\smallskip{}";
+				: "\\smallskip{}";
 	case MEDSKIP:   return kp ? "\\vspace*{\\medskipamount}"
-				  : "\\medskip{}";
+				: "\\medskip{}";
 	case BIGSKIP:   return kp ? "\\vspace*{\\bigskipamount}"
-				  : "\\bigskip{}";
+				: "\\bigskip{}";
 	case VFILL:     return kp ? "\\vspace*{\\fill}"
-				  : "\\vfill{}";
+				: "\\vfill{}";
 	case LENGTH:    return kp ? "\\vspace*{" + len.asLatexString() + '}'
-				  : "\\vspace{" + len.asLatexString() + '}';
+				: "\\vspace{" + len.asLatexString() + '}';
 	}
-	return LString();  // should never be reached
+	return string();  // should never be reached
 }
 
 
-int VSpace::inPixels() const
+int VSpace::inPixels(BufferView * bv) const
 {
 	// Height of a normal line in pixels (zoom factor considered)
-	int height = current_view->currentBuffer()->text->DefaultHeight(); // [pixels]
+	int height = bv->text->defaultHeight(); // [pixels]
+	int skip = 0;
+	int width = bv->workWidth();
+
+	if (kin == DEFSKIP)
+	    skip = bv->buffer()->params.getDefSkip().inPixels(bv);
+
+	return inPixels(height, skip, width);
+}
 
+int VSpace::inPixels(int default_height, int default_skip, int default_width) const
+{
+	// Height of a normal line in pixels (zoom factor considered)
+	int height = default_height; // [pixels]
+	
 	// Zoom factor specified by user in percent
-	float const zoom = lyxrc->zoom / 100.0; // [percent]
+	float const zoom = lyxrc.zoom / 100.0; // [percent]
 
 	// DPI setting for monitor: pixels/inch
-	float const dpi = lyxrc->dpi; // screen resolution [pixels/inch]
+	float const dpi = lyxrc.dpi; // screen resolution [pixels/inch]
 
 	// We want the result in pixels
 	float result, value;
@@ -517,16 +578,16 @@ int VSpace::inPixels() const
 	case NONE: return 0;
 
 	case DEFSKIP:
-	  return current_view->currentBuffer()->params.getDefSkip().inPixels();
+		return default_skip;
 
-	// This is how the skips are normally defined by
-	// LateX.  But there should be some way to change
-	// this per document.
-	case SMALLSKIP: return height/4;
-	case MEDSKIP:   return height/2;
+		// This is how the skips are normally defined by
+		// LateX.  But there should be some way to change
+		// this per document.
+	case SMALLSKIP: return height / 4;
+	case MEDSKIP:   return height / 2;
 	case BIGSKIP:   return height;
-	case VFILL:     return 3*height;
-		        // leave space for the vfill symbol
+	case VFILL:     return 3 * height;
+		// leave space for the vfill symbol
 	case LENGTH:
 		// Pixel values are scaled so that the ratio
 		// between lengths and font sizes on the screen
@@ -557,7 +618,7 @@ int VSpace::inPixels() const
 		case LyXLength::DD:
 			// Didot: 1157dd = 1238 pt?
 			result = zoom * dpi * value
-				/ (72.27/(0.376 * 2.845)); // 67.559735
+				/ (72.27 / (0.376 * 2.845)); // 67.559735
 			break;
 		case LyXLength::MM:
 			// Millimeter: 1 mm = 1/25.4 inch
@@ -567,12 +628,12 @@ int VSpace::inPixels() const
 		case LyXLength::PC:
 			// Pica: 1 pc = 12 pt
 			result = zoom * dpi * value
-				/ (72.27/12); // 6.0225
+				/ (72.27 / 12); // 6.0225
 			break;
 		case LyXLength::CC:
 			// Cicero: 1 cc = 12 dd
 			result = zoom * dpi * value
-				/ (72.27/ (12*0.376*2.845)); // 5.6299779
+				/ (72.27 / (12 * 0.376 * 2.845)); // 5.6299779
 			break;
 		case LyXLength::CM:
 			// Centimeter: 1 cm = 1/2.54 inch
@@ -592,9 +653,15 @@ int VSpace::inPixels() const
 			result = zoom * value * height / 2; // Why 2?
 			break;
 		case LyXLength::MU: // This is probably only allowed in
-			            // math mode
+			// math mode
 			result = zoom * value * height;
 			break;
+		case LyXLength::PW: // Always % of workarea
+		case LyXLength::PE:
+		case LyXLength::PP:
+		case LyXLength::PL:
+			result = value * default_width / 100;
+			break;
 		case LyXLength::UNIT_NONE:
 			result = 0;  // this cannot happen
 			break;