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

diff --git a/src/vspace.C b/src/vspace.C
index d442fa9794..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 1995 Matthias Ettrich
- *          Copyright 1995-1999 The LyX Team.
+ *           Copyright 1995 Matthias Ettrich
+ *           Copyright 1995-2001 The LyX Team.
  *
- * ======================================================*/
+ * ====================================================== */
 
 #include <config.h>
 
@@ -15,129 +14,172 @@
 #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 <cstdio>
-#include <cstring>
 #include "BufferView.h"
 #include "support/lstrings.h"
 
-extern LyXRC * lyxrc;
-extern BufferView *current_view;
+
+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 (string 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 inline void advance (string & data, unsigned 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)
 {
 	data.erase(0, n);
 }
 
-static inline bool isEndOfData (string const & data)
+
+inline
+bool isEndOfData(string const & data)
 {
-	return frontStrip (data).empty();
+	return frontStrip(data).empty();
 }
 
-static char nextToken (string & data)
+
+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 (prefixIs(data, "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 (prefixIs(data, "minus")) {
-		advance (data, 5);
+	} else if (prefixIs(data, "minus")) {
+		lyx_advance(data, 5);
 		return '-';
-	}
-	else {
-		string::size_type i;
-
-		// I really mean assignment ("=") below, not equality!
-		if ((i = data.find_first_not_of("0123456789.")) != string::npos) {
-			if (number_index > 3) return 'E';  // Error
-                        string buffer = data.substr(0, i);
-			if (sscanf (buffer.c_str(),
-				    "%f", &number[number_index]) == 1) {
-				advance (data, i);
+	} 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 = data
-			     .find_first_of("abcdefghijklmnopqrstuvwxyz")) != string::npos) {
-			if (unit_index > 3) return 'E';  // Error
-			string buffer = data.substr(0, i);
-			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;
 				return 'u';
-			} else
-				return 'E';  // Error
-		} else
-			return 'E';  // Error
+			} else return 'E';  // Error
+		}
+		return 'E';  // Error
 	}
 }
 
-static struct {
+
+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;
 };
 
+
+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"
@@ -163,13 +205,13 @@ bool isValidGlueLength (string const & data, LyXGlueLength * result)
 	// 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
@@ -202,12 +244,12 @@ bool isValidGlueLength (string 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;
 }
@@ -219,21 +261,23 @@ bool isValidLength(string const & data, LyXLength * result)
 	/// 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;
 
-        string   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
@@ -258,12 +302,13 @@ bool isValidLength(string const & data, LyXLength * result)
 	// 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(string const & data)
@@ -278,18 +323,34 @@ LyXLength::LyXLength(string const & data)
 	}
 }
 
-bool LyXLength::operator== (LyXLength const & other) const
+
+string const LyXLength::asString() const
 {
-	return (val == other.val &&
-		uni == other.uni);
+	ostringstream buffer;
+	buffer << val << unit_name[uni]; // setw?
+	return buffer.str().c_str();
 }
 
-string LyXLength::asString() const
-{
-	char buffer[20];
 
-	sprintf (buffer, "%g%s", val, unit_name[uni]);
-	return string (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();
 }
 
 
@@ -303,97 +364,94 @@ LyXGlueLength::LyXGlueLength (string const & data)
 	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 const & other) const
+string const LyXGlueLength::asString() const
 {
-	return (val == other.val && 
-		uni == other.uni &&
-		plus_val  == other.plus_val &&
-		plus_uni  == other.plus_uni &&
-		minus_val == other.minus_val &&
-		minus_uni == other.minus_uni);
-}
-
+	ostringstream buffer;
 
-string 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]);
+					buffer << val << "+-"
+					       << plus_val << unit_name[uni];
 				else
-					sprintf (buffer, "%g+%g-%g%s",
-						 val, plus_val, minus_val, 
-						 unit_name[uni]);
+					buffer << 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]);
+				if (plus_uni == minus_uni
+				    && plus_val == minus_val)
+					buffer << 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]);
+					buffer << 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]);
+				buffer << val << '+' << plus_val
+				       << unit_name[uni];
 			else
-				sprintf (buffer, "%g%s+%g%s",
-					 val,      unit_name[uni],
-					 plus_val, unit_name[plus_uni]);
+				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]);
+				buffer << val << '-' << minus_val
+				       << unit_name[uni];
+	
 			else
-				sprintf (buffer, "%g%s-%g%s",
-					 val,       unit_name[uni],
-					 minus_val, unit_name[minus_uni]);
+				buffer << val << unit_name[uni]
+				       << '-' << minus_val
+				       << unit_name[minus_uni];
 		else
-			sprintf (buffer, "%g%s", val, unit_name[uni]);
-	return string (buffer);
+			buffer << val << unit_name[uni];
+
+	return buffer.str().c_str();
 }
 
 
-string 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 string (buffer);
+			buffer << val << unit_name[uni];
+
+	return buffer.str().c_str();
 }
 
 
@@ -423,7 +481,7 @@ VSpace::VSpace (string const & data)
 	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.
@@ -433,22 +491,22 @@ VSpace::VSpace (string const & data)
 }
 
 
-bool VSpace::operator== (VSpace const & other) const
+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;
 }
 
 
-string VSpace::asLyXCommand() const
+string const VSpace::asLyXCommand() const
 {
         string result;
 
@@ -468,37 +526,50 @@ string VSpace::asLyXCommand() const
 }
 
 
-string VSpace::asLatexCommand() const
+string const VSpace::asLatexCommand(BufferParams const & params) const
 {
 	switch (kin) {
 	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 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;
@@ -507,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
@@ -547,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
@@ -557,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
@@ -582,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;