First part of hyphenation! And some minor changes in "lout".

22 files changed, 1653 insertions, 641 deletions

diff --git a/doc/dw-line-breaking.doc b/doc/dw-line-breaking.doc
new file mode 100644
index 00000000..43d7d448
--- /dev/null
+++ b/doc/dw-line-breaking.doc
@@ -0,0 +1,205 @@
+/** \page dw-line-breaking Changes in Line-Breaking
+
+<div style="border: 2px solid #ff0000; padding: 0.5em 1em;
+background-color: #ffe0e0"><b>Warning:</b> Unsorted collection of
+notes. Should be incorporated into dw::Textblock.</div>
+
+<ul>
+<li>Motivation: opimized line breaking and introduction of penalties.</li>
+<li>Definition of word: hyphenationed word consists of multiple words.</li>
+<li>Splitting up: dw/textblock.cc and dw/textblock_linebreaking.cc</li>
+<li>Test HTML files in the <i>test</i> directory.</li>
+<li>Adjust dw::Textblock::HYPHEN_BREAK.</li>
+</ul>
+
+<h2>Literature</h2>
+
+Although dillo does not (yet?) implement the algorithm TeX uses for
+line breaking, this document shares much of the notation used by the
+article <i>Breaking Paragraphs Into Lines</i> by Donald E. Knuth and
+Michael F. Plass; originally published in: Software -- Practice and
+Experience <b>11</b> (1981), 1119-1184; reprinted in: <i>Digital
+Typography</i> by Donalt E. Knuth, CSLI Publications 1999. Anyway an
+interesting reading.
+
+
+<h2>Criteria for Line-Breaking</h2>
+
+Currently, a word (represented by dw::Textblock::Word) has the
+following attributes related to line-breaking:
+
+<ul>
+
+<li> the width of the word itself, represented by dw::Textblock::Word::size;
+<li> the width of the space following the word, represented by
+dw::Textblock::Word::origSpace.
+</ul>
+
+[TODO: When is breaking between two words not permitted?]
+
+In a more mathematical notation, the \f$i\f$th word has got a width
+\f$w_i\f$ and a space \f$s_i\f$.
+
+With hyphenation, the criteria are refined. Hyphenation should only be
+used when otherwise line breaking results in very large spaces. So, we
+define:
+
+<ul>
+<li>the badness \f$\beta\f$ of a line, which is the greater the more the
+spaces between the words differ from the ideal space;
+<li>a penalty \f$p\f$ for any possible break point.
+</ul>
+
+The goal is to find those break points, where \f$\beta + p\f$ is
+minimal.
+
+Examples for the penalty \f$p\f$:
+
+<ul>
+<li>0 for normal line breaks (between words);
+<li>\f$\infty\f$ to prevent a line break at all costs;
+<li>\f$-\infty\f$ to force a line <li>a value > 0 for hyphens.
+</ul>
+
+[TODO: which value exactly for hyphens?]
+
+So we need the following values:
+
+<ul>
+<li> \f$w_i\f$ (the width of the word \f$i\f$ itself);
+<li> \f$s_i\f$ (the width of the space following the word \f$i\f$);
+<li> the strechability \f$y_i\f$, a value denoting how much the space
+after word\f$i\f$ can be streched (typically \f${1\over 2} s_i\f$);	
+<li> the shrinkability \f$y_i\f$, a value denoting how much the space
+after word\f$i\f$ can be shrunken (typically \f${1\over 3} s_i\f$);
+<li> the penalty \f$p_i\f$, if the line is broken after word \f$i\f$;
+<li> a width \f$h_i\f$, which is added, when the line is broken after
+word \f$i\f$.
+</ul>
+
+\f$h_i\f$ is the width of the hyphen, if the word \f$i\f$ is a part of
+the hyphenated word (except the last part); otherwise 0.
+
+Let \f$l\f$ be the (ideal) width (length) of the line. Furthermore,
+all words from \f$a\f$ to \f$b\f$ are added to the line. \f$a\f$ is
+fixed: we do not modify the previous lines anymore; but our task is to
+find a suitable \f$b\f$.
+
+We define:
+
+\f[W_a^b = \sum_{i=a}^{b} w_i + \sum_{i=a}^{b-1} s_i + h_b\f]
+
+\f[Y_a^b = \sum_{i=a}^{b-1} y_i\f]
+
+\f[Z_a^b = \sum_{i=a}^{b-1} z_i\f]
+
+
+\f$W_a^b\f$ is the total width, \f$Y_a^b\f$ the total strechability, and
+\f$Z_a^b\f$ the total shrinkability.
+
+Furthermore the <i>adjustment ratio</i> \f$r_a^b\f$:
+
+<ul>
+<li>in the ideal case that \f$W_a^b = l\f$: \f$r_a^b = 0\f$;
+<li>if \f$W_a^b < l\f$: \f$r_a^b = (l - W_a^b) / Y_a^b\f$ (\f$r_a^b < 0\f$ in
+this case);
+<li>if \f$W_a^b > l\f$: \f$r_a^b = (l - W_a^b) / Z_a^b\f$ (\f$r_a^b < 0\f$ in
+this case).
+</ul>
+
+The badness \f$\beta_a^b\f$ is defined as follows:
+
+<ul>
+<li>if \f$r_a^b\f$ is undefined or \f$r_a^b < -1\f$: \f$\beta_a^b = \infty\f$;
+<li>otherwise: \f$\beta_a^b = |r_a^b|^3\f$
+</ul>
+
+The goal is to find the value of \f$b\f$ where \f$\beta_a^b + p_b\f$
+is minimal. (\f$a\f$ is given, since we do not modify the previous
+lines.)
+
+After a couple of words, it is not predictable weather this minimum
+has already been reached. There are two cases where this is possible
+for a given \f$b'\f$:
+
+<ul>
+<li>\f$\beta_{b'}^a = \infty\f$ (line gets too tight): \f$a \le b <
+b'\f$, the minimun has to be searched between these two values;
+<li>\f$p_{b'} = -\infty\f$ (forced line break): \f$a \le b \le b'\f$
+(there may be another minimum of \f$\beta_a^b\f$ before; note the
+\f$\le\f$ instead of \f$<\f$).
+</ul>
+
+This also means, that all lines must be finalized with a forced line
+break.
+
+[TODO: Change: only adding complete lines, which leads to "hanging"
+words; temporary lines.]
+
+<h2>Soft Hyphens</h2>
+
+Calculating the width causes some problems, since it is not required
+that the width of text "AB" is identical to the width of "A" plus the
+width of "B". Instead, kerning, ligatures etc. may lead to other
+results. For this reason, a word is also always drawn as a whole.
+
+[TODO: Translate the following text to English.]
+
+<pre>
+Als Beispiel Wort aus vier trennbaren Silben: A-B-C-D
+
+3 mögliche Trennstelle, daher 8 mögliche Trennungen (allerdings einige
+unwahrscheinlich):
+
+ABCD, ABC-D, AB-CD, AB-C-D, A-BCD, A-BC-D, A-B-CD, A-B-C-D,
+
+w sei Wortbreite, l das Ergebnis von textWidth. Zwingende Bedingungen
+(bezieht sich auf die Teile, wo kein Trennstrich vorkommt; bei
+Trennstrichen kann man eventuell improvisieren):
+
+ABCD                           => w(A) + w(B) + w(C) + w(D) = l(ABCD)
+A-BCD                          => w(B) + w(C) + w(D) = l(BCD)
+AB-CD, A-B-CD                  => w(C) + w(D) = l(CD)
+ABC-D, AB-C-D, A-BC-D, A-B-C-D => w(D) = l(D)
+
+Also einfache Berechnung:
+
+w(D) = l(D)
+w(C) = l(CD) - w(D)
+w(B) = l(BCD) - (w(C) + w(D))
+w(A) = l(ABCD) - (w(B) + w(C) + w(D))
+
+Bei den Breiten inklusive Trennstrich ergibt sich eine
+Überbestimmtheit (bei konsanter Trennstrichbreite pro Wort). Daher
+wird einfach eine feste Trennstrichbreite angenommen:
+
+w(A-)  = w(A) + l(-)
+w(AB-) = w(A) + w(B) + l(-)
+
+usw.
+</pre>
+
+<h2>Bugs</h2>
+
+<h3>Major</h3>
+
+<ul>
+<li>Collapsing spaces and collapsing margins do not work yet. (Are
+    collapsing spaces still needed anyway?)</li>
+<li>List items (and aligned table cells) have to be reviewed (usage of
+    dw::Textblock::line1Offset).</li>
+<li>Sometimes, lines are too wide. It seems that this difference is
+    exacly the width of a hyphen.
+</ul>
+
+<h3>Minor</h3>
+
+<ul>
+<li>Should dw::core::Content::BREAK still be used? Currently, this is
+    redundant to dw::Textblock::BadnessAndPenalty.</li>
+<li>The calculation of badness is designed for justified text. For
+    other alignments, it may be modified. (TODO: document this in
+    detail.)</li>
+</ul>
+
+*/
diff --git a/doc/index.doc b/doc/index.doc
index 9892f177..59de8cd8 100644
--- a/doc/index.doc
+++ b/doc/index.doc
@@ -23,23 +23,23 @@ GLib. For an overview on all this, take a look at \ref lout.
 GtkObject is replaced by the following:
 
 <ul>
-<li> object::Object is a common base class for many classes used dillo. In
-     the namespace ::object, there are also some more common classes and
-     interfaces.
+<li> lout::object::Object is a common base class for many classes used
+     dillo. In the namespace lout::object, there are also some more common
+     classes and interfaces.
 
-<li> A sub class of object::Object is identity::IdentifiableObject, which
-     allows to determine the class at run-time (equivalent to GTK_CHECK_CAST
-     in GtkObject).
+<li> A sub class of lout::object::Object is
+     lout::identity::IdentifiableObject, which allows to determine the
+     class at run-time (equivalent to GTK_CHECK_CAST in GtkObject).
 
-<li> For signals, there is the namespace ::signal.
+<li> For signals, there is the namespace lout::signal.
 </ul>
 
-Hash tables, linked lists etc. can be found in the ::container namespace,
+Hash tables, linked lists etc. can be found in the lout::container namespace,
 several useful macros from GLib have been implemented as inline functions
-in the ::misc namespace.
+in the lout::misc namespace.
 
 As an alternative to the macros defined in list.h, there is also a template
-class, misc::SimpleVector, which does the same.
+class, lout::misc::SimpleVector, which does the same.
 
 <h3>Changes in Dw</h3>
 
diff --git a/doc/lout.doc b/doc/lout.doc
index 0d5be679..7f00d7b8 100644
--- a/doc/lout.doc
+++ b/doc/lout.doc
@@ -6,7 +6,7 @@ overview.
 
 <h2>Common Base Class</h2>
 
-Many classes are derived from object::Object, which defines some
+Many classes are derived from lout::object::Object, which defines some
 general methods. See there for more information.
 
 For the case, that you need primitive C++ types, there are some
@@ -14,47 +14,47 @@ wrappers:
 
 <table>
 <tr><th>C++ Type         <th>Wrapper Class
-<tr><td>void*            <td>object::Pointer
-<tr><td>specific pointer <td>object::TypedPointer (template class)
-<tr><td>int              <td>object::Integer
-<tr><td>const char*      <td>object::ConstString
-<tr><td>char*            <td>object::String
+<tr><td>void*            <td>lout::object::Pointer
+<tr><td>specific pointer <td>lout::object::TypedPointer (template class)
+<tr><td>int              <td>lout::object::Integer
+<tr><td>const char*      <td>lout::object::ConstString
+<tr><td>char*            <td>lout::object::String
 </table>
 
 
 <h2>Containers</h2>
 
-In the namespace ::container, several container classes are defined,
-which all deal with instances of object::Object.
+In the namespace lout::container, several container classes are defined,
+which all deal with instances of lout::object::Object.
 
 <h3>Untyped Containers</h3>
 
-In container::untyped, there are the following containers:
+In lout::container::untyped, there are the following containers:
 
 <ul>
-<li>container::untyped::Vector, a dynamically increases array,
-<li>container::untyped::List, a linked list,
-<li>container::untyped::HashTable, a hash table, and
-<li>container::untyped::Stack, a stack.
+<li>lout::container::untyped::Vector, a dynamically increases array,
+<li>lout::container::untyped::List, a linked list,
+<li>lout::container::untyped::HashTable, a hash table, and
+<li>lout::container::untyped::Stack, a stack.
 </ul>
 
 All provide specific methods, but since they have a common base class,
-container::untyped::Collection, they all provide iterators, by the
-method container::untyped::Collection::iterator.
+lout::container::untyped::Collection, they all provide iterators, by the
+method lout::container::untyped::Collection::iterator.
 
 <h3>Typed Containers</h3>
 
-container::typed provides wrappers for the container classes defined
-in container::untyped, which are more type safe, by using C++
+lout::container::typed provides wrappers for the container classes defined
+in lout::container::untyped, which are more type safe, by using C++
 templates.
 
 
 <h2>Signals</h2>
 
 For how to connect objects at run-time (to reduce dependencies), take a
-look at the ::signal namespace.
+look at the lout::signal namespace.
 
-There is also a base class signal::ObservedObject, which implements
+There is also a base class lout::signal::ObservedObject, which implements
 signals for deletion.
 
 
@@ -67,28 +67,28 @@ see the file for mor informations.
 <h2>Identifying Classes at Runtime</h2>
 
 If the class of an object must be identified at runtime,
-identity::IdentifiableObject should be used as the base class, see
-there for more details.
+lout::identity::IdentifiableObject should be used as the base class,
+see there for more details.
 
 
 <h2>Miscellaneous</h2>
 
-The ::misc namespace provides several miscellaneous stuff:
+The lout::misc namespace provides several miscellaneous stuff:
 
 <ul>
 <li> In some contexts, it is necessary to compare objects
-     (less/greater), for this, also misc::Comparable must be
-     implemented. For example., container::untyped::Vector::sort and
-     container::typed::Vector::sort cast the elements to
-     misc::Comparable. This can be mixed with object::Object.
-<li> misc::SimpleVector, a simple, template based vector class (not
-     depending on object::Object),
-<li> misc::StringBuffer, class for fast concatenation of a large number
+     (less/greater), for this, also lout::misc::Comparable must be
+     implemented. For example., lout::container::untyped::Vector::sort and
+     lout::container::typed::Vector::sort cast the elements to
+     lout::misc::Comparable. This can be mixed with lout::object::Object.
+<li> lout::misc::SimpleVector, a simple, template based vector class (not
+     depending on lout::object::Object),
+<li> lout::misc::StringBuffer, class for fast concatenation of a large number
      of strings,
-<li> misc::BitSet implements a bitset.
-<li> useful (template) functions (misc::min, misc::max), and
-<li> some functions useful for runtime checks (misc::assert,
-     misc::assertNotReached).
+<li> lout::misc::BitSet implements a bitset.
+<li> useful (template) functions (lout::misc::min, lout::misc::max), and
+<li> some functions useful for runtime checks (lout::misc::assert,
+     lout::misc::assertNotReached).
 </ul>
 
 */
diff --git a/doc/rounding-errors.doc b/doc/rounding-errors.doc
index 433d6ed9..133a1fe5 100644
--- a/doc/rounding-errors.doc
+++ b/doc/rounding-errors.doc
@@ -15,10 +15,10 @@ implementation would result in something, for which
 because of rounding errors, due to the integer division. This can be
 avoided by transforming the formula into
 
-\f[y_i = {(\sum_{j=0}^{j=i} x_j) a \over b} - \sum_{j=0}^{j=i} y_j\f]
+\f[y_i = {(\sum_{j=0}^{j=i} x_j) a \over b} - \sum_{j=0}^{j=i-1} y_j\f]
 
 Of corse, when all \f$y_i\f$ are calculated in a sequence,
-\f$\sum_{j=0}^{j=i} x_j\f$ and \f$\sum_{j=0}^{j=i} y_j\f$ can be
+\f$\sum_{j=0}^{j=i} x_j\f$ and \f$\sum_{j=0}^{j=i-1} y_j\f$ can be
 accumulated in the same loop.
 
 */
\ No newline at end of file
diff --git a/dw/Makefile.am b/dw/Makefile.am
index 3014b35d..4cd53099 100644
--- a/dw/Makefile.am
+++ b/dw/Makefile.am
@@ -68,6 +68,7 @@ libDw_widgets_a_SOURCES = \
 	tablecell.cc \
 	tablecell.hh \
 	textblock.cc \
+	textblock_linebreaking.cc \
 	textblock.hh
 
 EXTRA_DIST = preview.xbm
diff --git a/dw/fltkviewbase.cc b/dw/fltkviewbase.cc
index 1d385cf9..240937e2 100644
--- a/dw/fltkviewbase.cc
+++ b/dw/fltkviewbase.cc
@@ -531,9 +531,9 @@ FltkWidgetView::~FltkWidgetView ()
 }
 
 void FltkWidgetView::drawText (core::style::Font *font,
-                             core::style::Color *color,
-                             core::style::Color::Shading shading,
-                             int X, int Y, const char *text, int len)
+                               core::style::Color *color,
+                               core::style::Color::Shading shading,
+                               int X, int Y, const char *text, int len)
 {
    FltkFont *ff = (FltkFont*)font;
    fl_font(ff->font, ff->size);
diff --git a/dw/tablecell.cc b/dw/tablecell.cc
index 5b93fe86..90dc310d 100644
--- a/dw/tablecell.cc
+++ b/dw/tablecell.cc
@@ -42,12 +42,12 @@ TableCell::~TableCell()
 {
 }
 
-void TableCell::wordWrap(int wordIndex)
+void TableCell::wordWrap(int wordIndex, bool wrapAll)
 {
    Textblock::Word *word;
    const char *p;
 
-   Textblock::wordWrap (wordIndex);
+   Textblock::wordWrap (wordIndex, wrapAll);
 
    if (charWordIndex == -1) {
       word = words->getRef (wordIndex);
diff --git a/dw/tablecell.hh b/dw/tablecell.hh
index 318d1f4e..4bb8633c 100644
--- a/dw/tablecell.hh
+++ b/dw/tablecell.hh
@@ -12,7 +12,7 @@ private:
    int charWordIndex, charWordPos;
 
 protected:
-   void wordWrap(int wordIndex);
+   void wordWrap (int wordIndex, bool wrapAll);
 
    int getValue ();
    void setMaxValue (int maxValue, int value);
diff --git a/dw/textblock.cc b/dw/textblock.cc
index 3778687c..df0b926e 100644
--- a/dw/textblock.cc
+++ b/dw/textblock.cc
@@ -18,13 +18,12 @@
  */
 
 
-
 #include "textblock.hh"
 #include "../lout/msg.h"
 #include "../lout/misc.hh"
 
 #include <stdio.h>
-#include <limits.h>
+#include <math.h>
 
 /*
  * Local variables
@@ -51,8 +50,6 @@ Textblock::Textblock (bool limitTextWidth)
    hasListitemValue = false;
    innerPadding = 0;
    line1Offset = 0;
-   line1OffsetEff = 0;
-   ignoreLine1OffsetSometimes = false;
    mustQueueResize = false;
    redrawY = 0;
    lastWordDrawn = -1;
@@ -67,13 +64,12 @@ Textblock::Textblock (bool limitTextWidth)
     * TODO: Some tests would be useful.
     */
    lines = new misc::SimpleVector <Line> (1);
+   nonTemporaryLines = 0;
    words = new misc::SimpleVector <Word> (1);
    anchors = new misc::SimpleVector <Anchor> (1);
 
    //DBG_OBJ_SET_NUM(this, "num_lines", num_lines);
 
-   lastLineWidth = 0;
-   lastLineParMax = 0;
    wrapRef = -1;
 
    //DBG_OBJ_SET_NUM(this, "last_line_width", last_line_width);
@@ -112,6 +108,7 @@ Textblock::~Textblock ()
          delete word->content.widget;
       word->style->unref ();
       word->spaceStyle->unref ();
+      word->hyphenStyle->unref ();
    }
 
    for (int i = 0; i < anchors->size(); i++) {
@@ -139,11 +136,21 @@ Textblock::~Textblock ()
 void Textblock::sizeRequestImpl (core::Requisition *requisition)
 {
    rewrap ();
+   showMissingLines ();
 
    if (lines->size () > 0) {
       Line *lastLine = lines->getRef (lines->size () - 1);
-      requisition->width =
-         misc::max (lastLine->maxLineWidth, lastLineWidth);
+      requisition->width = lastLine->maxLineWidth;
+
+      PRINTF ("[%p] SIZE_REQUEST: lines[0]->boxAscent = %d\n",
+              this, lines->getRef(0)->boxAscent);
+      PRINTF ("[%p] SIZE_REQUEST: lines[%d]->top = %d\n", 
+              this, lines->size () - 1, lastLine->top);
+      PRINTF ("[%p] SIZE_REQUEST: lines[%d]->boxAscent = %d\n", 
+              this, lines->size () - 1, lastLine->boxAscent);
+      PRINTF ("[%p] SIZE_REQUEST: lines[%d]->boxDescent = %d\n", 
+              this, lines->size () - 1, lastLine->boxDescent);
+
       /* Note: the breakSpace of the last line is ignored, so breaks
          at the end of a textblock are not visible. */
       requisition->ascent = lines->getRef(0)->boxAscent;
@@ -151,7 +158,7 @@ void Textblock::sizeRequestImpl (core::Requisition *requisition)
          + lastLine->boxAscent + lastLine->boxDescent -
          lines->getRef(0)->boxAscent;
    } else {
-      requisition->width = lastLineWidth;
+      requisition->width = 0; // before: lastLineWidth;
       requisition->ascent = 0;
       requisition->descent = 0;
    }
@@ -162,6 +169,9 @@ void Textblock::sizeRequestImpl (core::Requisition *requisition)
 
    if (requisition->width < availWidth)
       requisition->width = availWidth;
+
+   PRINTF("[%p] SIZE_REQUEST: %d x %d + %d\n", this, requisition->width,
+          requisition->ascent, requisition->descent);
 }
 
 /**
@@ -205,23 +215,27 @@ void Textblock::getExtremesImpl (core::Extremes *extremes)
    int wordIndex, lineIndex;
    int parMax;
 
-   //DBG_MSG (widget, "extremes", 0, "getExtremesImpl");
-   //DBG_MSG_START (widget);
+   showMissingLines ();
 
    if (lines->size () == 0) {
       /* empty page */
       extremes->minWidth = 0;
       extremes->maxWidth = 0;
+
+      PRINTF ("GET_EXTREMES: empty (but %d words)\n", words->size());
    } else if (wrapRef == -1) {
       /* no rewrap necessary -> values in lines are up to date */
       line = lines->getRef (lines->size () - 1);
       extremes->minWidth = line->maxParMin;
-      extremes->maxWidth = misc::max (line->maxParMax, lastLineParMax);
-      //DBG_MSG (widget, "extremes", 0, "simple case");
+      extremes->maxWidth = line->maxParMax;
+
+      PRINTF ("GET_EXTREMES: no rewrap => %d, %d\n",
+              line->maxParMin, line->maxParMax);
    } else {
       /* Calculate the extremes, based on the values in the line from
          where a rewrap is necessary. */
-      //DBG_MSG (widget, "extremes", 0, "complex case");
+
+      PRINTF ("GET_EXTREMES: complex case ...\n");
 
       if (wrapRef == 0) {
          extremes->minWidth = 0;
@@ -232,97 +246,65 @@ void Textblock::getExtremesImpl (core::Extremes *extremes)
          extremes->minWidth = line->maxParMin;
          extremes->maxWidth = line->maxParMax;
          parMax = line->parMax;
-
-         //DBG_MSGF (widget, "extremes", 0, "parMin = %d", parMin);
       }
 
-      //_MSG ("*** parMin = %d\n", parMin);
-
       int prevWordSpace = 0;
       for (lineIndex = wrapRef; lineIndex < lines->size (); lineIndex++) {
-         //DBG_MSGF (widget, "extremes", 0, "line %d", lineIndex);
-         //DBG_MSG_START (widget);
-         int parMin = 0;
-
          line = lines->getRef (lineIndex);
+         int parMin = 0;
 
          for (wordIndex = line->firstWord; wordIndex <= line->lastWord;
               wordIndex++) {
             word = words->getRef (wordIndex);
-            getWordExtremes (word, &wordExtremes);
 
+            getWordExtremes (word, &wordExtremes);
             if (wordIndex == 0) {
-               wordExtremes.minWidth += line1OffsetEff;
-               wordExtremes.maxWidth += line1OffsetEff;
-               //DEBUG_MSG (DEBUG_SIZE_LEVEL + 1,
-               //           "      (next plus %d)\n", line1OffsetEff);
+               wordExtremes.minWidth += line1Offset;
+               wordExtremes.maxWidth += line1Offset;
             }
 
+            extremes->minWidth = misc::max (extremes->minWidth,
+                                            wordExtremes.minWidth);
 
-            if (extremes->minWidth < wordExtremes.minWidth)
-               extremes->minWidth = wordExtremes.minWidth;
-
-            _MSG("parMax = %d, wordMaxWidth=%d, prevWordSpace=%d\n",
-                 parMax, wordExtremes.maxWidth, prevWordSpace);
             if (word->content.type != core::Content::BREAK)
                parMax += prevWordSpace;
             parMax += wordExtremes.maxWidth;
 
-            if (prevWord && !canBreakAfter(prevWord)) {
+            if (prevWord && !prevWord->badnessAndPenalty.lineMustBeBroken ())
                parMin += prevWordSpace + wordExtremes.minWidth;
-            } else {
+            else
                parMin = wordExtremes.minWidth;
-            }
 
-            if (extremes->minWidth < parMin) {
+            if (extremes->minWidth < parMin)
                extremes->minWidth = parMin;
-            }
 
             prevWordSpace = word->origSpace;
             prevWord = word;
-
-            //DEBUG_MSG (DEBUG_SIZE_LEVEL + 1,
-            //           "      word %s: maxWidth = %d\n",
-            //           word->content.text,
-            //           word_extremes.maxWidth);
          }
 
          if ((words->getRef(line->lastWord)->content.type
               == core::Content::BREAK ) ||
              lineIndex == lines->size () - 1 ) {
-
-            //DEBUG_MSG (DEBUG_SIZE_LEVEL + 2,
-            //           "   parMax = %d, after word %d (%s)\n",
-            //           parMax, line->last_word - 1,
-            //           word->content.text);
-
-            if (extremes->maxWidth < parMax)
-               extremes->maxWidth = parMax;
-
+            extremes->maxWidth = misc::max (extremes->maxWidth, parMax);
             prevWordSpace = 0;
             parMax = 0;
          }
-
-         //DBG_MSG_END (widget);
       }
 
-      //DEBUG_MSG (DEBUG_SIZE_LEVEL + 3, "   Result: %d, %d\n",
-      //           extremes->minWidth, extremes->maxWidth);
    }
 
-   //DBG_MSGF (widget, "extremes", 0, "width difference: %d + %d",
-   //          innerPadding, getStyle()->boxDiffWidth ());
-
    int diff = innerPadding + getStyle()->boxDiffWidth ();
    extremes->minWidth += diff;
    extremes->maxWidth += diff;
-
-   //DBG_MSG_END (widget);
 }
 
 
 void Textblock::sizeAllocateImpl (core::Allocation *allocation)
 {
+   PRINTF ("SIZE_ALLOCATE: %d, %d, %d x %d + %d\n",
+           allocation->x, allocation->y, allocation->width,
+           allocation->ascent, allocation->descent);
+
    int lineIndex, wordIndex;
    Line *line;
    Word *word;
@@ -461,16 +443,19 @@ void Textblock::markExtremesChange (int ref)
  */
 void Textblock::markChange (int ref)
 {
+   /* By the way: ref == -1 may have two different causes: (i) flush()
+      calls "queueResize (-1, true)", when no rewrapping is necessary;
+      and (ii) a word may have parentRef == -1 , when it is not yet
+      added to a line.  In the latter case, nothing has to be done
+      now, but addLine(...) will do everything neccessary. */
    if (ref != -1) {
-      //DBG_MSGF (page, "wrap", 0, "markChange (ref = %d)", ref);
-
       if (wrapRef == -1)
          wrapRef = ref;
       else
          wrapRef = misc::min (wrapRef, ref);
-
-      //DBG_OBJ_SET_NUM (this, "wrap_ref", wrapRef);
    }
+
+   PRINTF ("[%p] MARK_CHANGE (%d) => %d\n", this, ref, wrapRef);
 }
 
 void Textblock::setWidth (int width)
@@ -731,361 +716,6 @@ core::Iterator *Textblock::iterator (core::Content::Type mask, bool atEnd)
    return new TextblockIterator (this, mask, atEnd);
 }
 
-/*
- * ...
- *
- * availWidth is passed from wordWrap, to avoid calculating it twice.
- */
-void Textblock::justifyLine (Line *line, int availWidth)
-{
-   /* To avoid rounding errors, the calculation is based on accumulated
-    * values (*_cum). */
-   int i;
-   int origSpaceSum, origSpaceCum;
-   int effSpaceDiffCum, lastEffSpaceDiffCum;
-   int diff;
-
-   diff = availWidth - lastLineWidth;
-   if (diff > 0) {
-      origSpaceSum = 0;
-      for (i = line->firstWord; i < line->lastWord; i++)
-         origSpaceSum += words->getRef(i)->origSpace;
-
-      origSpaceCum = 0;
-      lastEffSpaceDiffCum = 0;
-      for (i = line->firstWord; i < line->lastWord; i++) {
-         origSpaceCum += words->getRef(i)->origSpace;
-
-         if (origSpaceCum == 0)
-            effSpaceDiffCum = lastEffSpaceDiffCum;
-         else
-            effSpaceDiffCum = diff * origSpaceCum / origSpaceSum;
-
-         words->getRef(i)->effSpace = words->getRef(i)->origSpace +
-            (effSpaceDiffCum - lastEffSpaceDiffCum);
-         //DBG_OBJ_ARRSET_NUM (this, "words.%d.effSpace", i,
-         //                    words->getRef(i)->effSpace);
-
-         lastEffSpaceDiffCum = effSpaceDiffCum;
-      }
-   }
-}
-
-
-Textblock::Line *Textblock::addLine (int wordIndex, bool newPar)
-{
-   Line *lastLine;
-
-   //DBG_MSG (page, "wrap", 0, "addLine");
-   //DBG_MSG_START (page);
-
-   lines->increase ();
-   //DBG_OBJ_SET_NUM(this, "num_lines", lines->size ());
-
-   //DEBUG_MSG (DEBUG_REWRAP_LEVEL, "--- new line %d in %p, with word %d of %d"
-   //           "\n", lines->size () - 1, page, word_ind, words->size());
-
-   lastLine = lines->getRef (lines->size () - 1);
-
-   if (lines->size () == 1) {
-      lastLine->top = 0;
-      lastLine->maxLineWidth = line1OffsetEff;
-      lastLine->maxParMin = 0;
-      lastLine->maxParMax = 0;
-   } else {
-      Line *prevLine = lines->getRef (lines->size () - 2);
-
-      lastLine->top = prevLine->top + prevLine->boxAscent +
-                      prevLine->boxDescent + prevLine->breakSpace;
-      lastLine->maxLineWidth = prevLine->maxLineWidth;
-      lastLine->maxParMin = prevLine->maxParMin;
-      lastLine->maxParMax = prevLine->maxParMax;
-   }
-
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.top", lines->size () - 1,
-   //                    lastLine->top);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.maxLineWidth", lines->size () - 1,
-   //                    lastLine->maxLineWidth);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.maxParMin", lines->size () - 1,
-   //                    lastLine->maxParMin);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.maxParMax", lines->size () - 1,
-   //                    lastLine->maxParMax);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.parMin", lines->size () - 1,
-   //                    lastLine->parMin);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.parMax", lines->size () - 1,
-   //                    lastLine->parMax);
-
-   lastLine->firstWord = wordIndex;
-   lastLine->boxAscent = lastLine->contentAscent = 0;
-   lastLine->boxDescent = lastLine->contentDescent = 0;
-   lastLine->marginDescent = 0;
-   lastLine->breakSpace = 0;
-   lastLine->leftOffset = 0;
-
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.ascent", lines->size () - 1,
-   //                    lastLine->boxAscent);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.descent", lines->size () - 1,
-   //                    lastLine->boxDescent);
-
-   /* update values in line */
-   lastLine->maxLineWidth = misc::max (lastLine->maxLineWidth, lastLineWidth);
-
-   if (lines->size () > 1)
-      lastLineWidth = 0;
-   else
-      lastLineWidth = line1OffsetEff;
-
-   if (newPar) {
-      lastLine->maxParMax = misc::max (lastLine->maxParMax, lastLineParMax);
-      //DBG_OBJ_ARRSET_NUM (this, "lines.%d.maxParMax", lines->size () - 1,
-      //                    lastLine->maxParMax);
-
-      if (lines->size () > 1) {
-         lastLineParMax = 0;
-      } else {
-         lastLineParMax = line1OffsetEff;
-      }
-
-      //DBG_OBJ_SET_NUM(this, "lastLineParMax", lastLineParMax);
-   }
-
-   lastLine->parMax = lastLineParMax;
-
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.parMin", lines->size () - 1,
-   //                    lastLine->parMin);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.parMax", lines->size () - 1,
-   //                    lastLine->parMax);
-
-   //DBG_MSG_END (page);
-   return lastLine;
-}
-
-/*
- * This method is called in two cases: (i) when a word is added
- * (ii) when a page has to be (partially) rewrapped. It does word wrap,
- * and adds new lines if necessary.
- */
-void Textblock::wordWrap(int wordIndex)
-{
-   Line *lastLine;
-   Word *word;
-   int availWidth, lastSpace, leftOffset, len;
-   bool newLine = false, newPar = false, canBreakBefore = true;
-   core::Extremes wordExtremes;
-
-   //DBG_MSGF (page, "wrap", 0, "wordWrap (%d): %s, width = %d",
-   //          wordIndex, words->getRef(wordIndex)->content.text),
-   //          words->getRef(wordIndex)->size.width);
-   //DBG_MSG_START (page);
-
-   availWidth = this->availWidth - getStyle()->boxDiffWidth() - innerPadding;
-   if (limitTextWidth &&
-       layout->getUsesViewport () &&
-       availWidth > layout->getWidthViewport () - 10)
-      availWidth = layout->getWidthViewport () - 10;
-
-   word = words->getRef (wordIndex);
-   word->effSpace = word->origSpace;
-
-   /* Test whether line1Offset can be used. */
-   if (wordIndex == 0) {
-      if (ignoreLine1OffsetSometimes &&
-          line1Offset + word->size.width > availWidth) {
-         line1OffsetEff = 0;
-      } else {
-         int indent = 0;
-
-         if (word->content.type == core::Content::WIDGET &&
-             word->content.widget->blockLevel() == true) {
-            /* don't use text-indent when nesting blocks */
-         } else {
-            if (core::style::isPerLength(getStyle()->textIndent)) {
-               indent = misc::roundInt(this->availWidth *
-                        core::style::perLengthVal (getStyle()->textIndent));
-            } else {
-               indent = core::style::absLengthVal (getStyle()->textIndent);
-            }
-         }
-         line1OffsetEff = line1Offset + indent;
-      }
-   }
-
-   if (lines->size () == 0) {
-      //DBG_MSG (page, "wrap", 0, "first line");
-      newLine = true;
-      newPar = true;
-      lastLine = NULL;
-   } else {
-      Word *prevWord = words->getRef (wordIndex - 1);
-
-      lastLine = lines->getRef (lines->size () - 1);
-
-      if (prevWord->content.type == core::Content::BREAK) {
-         //DBG_MSG (page, "wrap", 0, "after a break");
-         /* previous word is a break */
-         newLine = true;
-         newPar = true;
-      } else if (!canBreakAfter (prevWord)) {
-         canBreakBefore = false;
-         // no break within nowrap
-         newLine = false;
-         newPar = false;
-         if (lastLineWidth + prevWord->origSpace + word->size.width >
-             availWidth)
-            markChange (lines->size () - 1);
-      } else if (lastLine->firstWord != wordIndex) {
-         // check if we need to break because nowrap sequence is following
-         newLine = false;
-         int lineWidthNeeded = lastLineWidth + prevWord->origSpace;
-         for (int i = wordIndex; i < words->size (); i++) {
-            Word *w = words->getRef (i);
-
-            if (w->content.type == core::Content::BREAK ||
-                (word->content.type == core::Content::WIDGET &&
-                 word->content.widget->blockLevel()))
-            break;
- 
-            lineWidthNeeded += w->size.width;
-
-            if (lineWidthNeeded > availWidth) {
-               newLine = true;
-               break;  
-            } else if (canBreakAfter (w)) {
-               break;
-            }
-
-            lineWidthNeeded += w->origSpace;
-         }
-      }
-   }
-
-   if (newLine) {
-      if (word->style->textAlign == core::style::TEXT_ALIGN_JUSTIFY &&
-          lastLine != NULL && !newPar) {
-         justifyLine (lastLine, availWidth);
-      }
-      lastLine = addLine (wordIndex, newPar);
-   }
-
-   lastLine->lastWord = wordIndex;
-   lastLine->boxAscent = misc::max (lastLine->boxAscent, word->size.ascent);
-   lastLine->boxDescent = misc::max (lastLine->boxDescent, word->size.descent);
-
-   len = word->style->font->ascent;
-   if (word->style->valign == core::style::VALIGN_SUPER)
-      len += len / 2;
-   lastLine->contentAscent = misc::max (lastLine->contentAscent, len);
-
-   len = word->style->font->descent;
-   if (word->style->valign == core::style::VALIGN_SUB)
-      len += word->style->font->ascent / 3;
-   lastLine->contentDescent = misc::max (lastLine->contentDescent, len);
-
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.ascent", lines->size () - 1,
-   //                    lastLine->boxAscent);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.descent", lines->size () - 1,
-   //                    lastLine->boxDescent);
-
-   if (word->content.type == core::Content::WIDGET) {
-      int collapseMarginTop = 0;
-
-      lastLine->marginDescent =
-         misc::max (lastLine->marginDescent,
-                    word->size.descent +
-                    word->content.widget->getStyle()->margin.bottom);
-
-      if (lines->size () == 1 &&
-          word->content.widget->blockLevel () &&
-          getStyle ()->borderWidth.top == 0 &&
-          getStyle ()->padding.top == 0) {
-         // collapse top margins of parent element and its first child
-         // see: http://www.w3.org/TR/CSS21/box.html#collapsing-margins
-         collapseMarginTop = getStyle ()->margin.top;
-      }
-
-      lastLine->boxAscent =
-            misc::max (lastLine->boxAscent,
-                       word->size.ascent,
-                       word->size.ascent
-                       + word->content.widget->getStyle()->margin.top
-                       - collapseMarginTop);
-
-   } else {
-      lastLine->marginDescent =
-         misc::max (lastLine->marginDescent, lastLine->boxDescent);
-
-      if (word->content.type == core::Content::BREAK)
-         lastLine->breakSpace =
-            misc::max (word->content.breakSpace,
-                       lastLine->marginDescent - lastLine->boxDescent,
-                       lastLine->breakSpace);
-   }
-
-   lastSpace = (wordIndex > 0) ? words->getRef(wordIndex - 1)->origSpace : 0;
-
-   if (!newLine)
-      lastLineWidth += lastSpace;
-   if (!newPar) {
-      lastLineParMax += lastSpace;
-   }
-
-   lastLineWidth += word->size.width;
-
-   getWordExtremes (word, &wordExtremes);
-   lastLineParMax += wordExtremes.maxWidth;
-
-   if (!canBreakBefore) {
-      lastLineParMin += wordExtremes.minWidth + lastSpace;
-      /* This may also increase the accumulated minimum word width.  */
-      lastLine->maxParMin = misc::max (lastLine->maxParMin, lastLineParMin);
-   } else {
-      lastLineParMin = wordExtremes.minWidth;
-      lastLine->maxParMin =
-         misc::max (lastLine->maxParMin, wordExtremes.minWidth);
-   }
-
-   //DBG_OBJ_SET_NUM(this, "lastLine_par_min", lastLineParMin);
-   //DBG_OBJ_SET_NUM(this, "lastLine_par_max", lastLineParMax);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.par_min", lines->size () - 1,
-   //                    lastLine->par_min);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.par_max", lines->size () - 1,
-   //                    lastLine->par_max);
-   //DBG_OBJ_ARRSET_NUM (this, "lines.%d.max_word_min", lines->size () - 1,
-   //                    lastLine->max_word_min);
-
-   /* Align the line.
-    * \todo Use block's style instead once paragraphs become proper blocks.
-    */
-   if (word->content.type != core::Content::BREAK) {
-      switch (word->style->textAlign) {
-      case core::style::TEXT_ALIGN_LEFT:
-      case core::style::TEXT_ALIGN_JUSTIFY:  /* see some lines above */
-      case core::style::TEXT_ALIGN_STRING:   /* handled elsewhere (in the
-                                                * future) */
-         leftOffset = 0;
-         break;
-      case core::style::TEXT_ALIGN_RIGHT:
-         leftOffset = availWidth - lastLineWidth;
-         break;
-      case core::style::TEXT_ALIGN_CENTER:
-         leftOffset = (availWidth - lastLineWidth) / 2;
-         break;
-      default:
-         /* compiler happiness */
-         leftOffset = 0;
-      }
-
-      /* For large lines (images etc), which do not fit into the viewport: */
-      if (leftOffset < 0)
-         leftOffset = 0;
-
-      lastLine->leftOffset = leftOffset;
-   }
-   mustQueueResize = true;
-
-   //DBG_MSG_END (page);
-}
-
 
 /**
  * Calculate the size of a widget within the page.
@@ -1144,93 +774,6 @@ void Textblock::calcWidgetSize (core::Widget *widget, core::Requisition *size)
    size->descent -= wstyle->margin.bottom;
 }
 
-/**
- * Rewrap the page from the line from which this is necessary.
- * There are basically two times we'll want to do this:
- * either when the viewport is resized, or when the size changes on one
- * of the child widgets.
- */
-void Textblock::rewrap ()
-{
-   int i, wordIndex;
-   Word *word;
-   Line *lastLine;
-
-   if (wrapRef == -1)
-      /* page does not have to be rewrapped */
-      return;
-
-   //DBG_MSGF (page, "wrap", 0,
-   //          "rewrap: wrapRef = %d, in page with %d word(s)",
-   //          wrapRef, words->size());
-   //DBG_MSG_START (page);
-
-   /* All lines up from wrapRef will be rebuild from the word list,
-    * the line list up from this position is rebuild. */
-   lines->setSize (wrapRef);
-   lastLineWidth = 0;
-   lastLineParMin = 0;
-   //DBG_OBJ_SET_NUM(this, "num_lines", lines->size ());
-   //DBG_OBJ_SET_NUM(this, "lastLine_width", lastLineWidth);
-
-   /* In the word list, start at the last word plus one in the line before. */
-   if (wrapRef > 0) {
-      /* Note: In this case, wordWrap() will immediately find the need
-       * to rewrap the line, since we start with the last one (plus one).
-       * This is also the reason, why lastLineWidth is set
-       * to the length of the line. */
-      lastLine = lines->getRef (lines->size () - 1);
-
-      lastLineParMax = lastLine->parMax;
-
-      // take line1OffsetEff into account, if lastLine is the first line
-      if (lines->size () - 1 == 0)
-         lastLineWidth = line1OffsetEff;
-
-      wordIndex = lastLine->lastWord + 1;
-      for (i = lastLine->firstWord; i < lastLine->lastWord; i++)
-         lastLineWidth += (words->getRef(i)->size.width +
-                           words->getRef(i)->origSpace);
-      lastLineWidth += words->getRef(lastLine->lastWord)->size.width;
-   } else {
-      lastLineParMax = 0;
-
-      wordIndex = 0;
-   }
-
-   for (; wordIndex < words->size (); wordIndex++) {
-      word = words->getRef (wordIndex);
-
-      if (word->content.type == core::Content::WIDGET)
-         calcWidgetSize (word->content.widget, &word->size);
-      wordWrap (wordIndex);
-
-      if (word->content.type == core::Content::WIDGET) {
-         word->content.widget->parentRef = lines->size () - 1;
-         //DBG_OBJ_SET_NUM (word->content.widget, "parent_ref",
-         //                 word->content.widget->parent_ref);
-      }
-
-      //DEBUG_MSG(DEBUG_REWRAP_LEVEL,
-      //          "Assigning parent_ref = %d to rewrapped word %d, "
-      //          "in page with %d word(s)\n",
-      //          lines->size () - 1, wordIndex, words->size());
-
-      /* todo_refactoring:
-      if (word->content.type == DW_CONTENT_ANCHOR)
-         p_Dw_gtk_viewport_change_anchor
-            (widget, word->content.anchor,
-             Dw_page_line_total_y_offset (page,
-                                          &page->lines[lines->size () - 1]));
-      */
-   }
-
-   /* Next time, the page will not have to be rewrapped. */
-   wrapRef = -1;
-
-   //DBG_MSG_END (page);
-}
-
 /*
  * Draw the decorations on a word.
  */
@@ -1314,14 +857,58 @@ void Textblock::drawText(core::View *view, core::style::Style *style,
 }
 
 /*
- * Draw a word of text.
+ * Draw a word of text. TODO New description;
  */
-void Textblock::drawWord(int wordIndex, core::View *view,core::Rectangle *area,
-                         int xWidget, int yWidgetBase)
+void Textblock::drawWord (Line *line, int wordIndex1, int wordIndex2,
+                          core::View *view, core::Rectangle *area,
+                          int xWidget, int yWidgetBase)
 {
-   Word *word = words->getRef(wordIndex);
+   core::style::Style *style = words->getRef(wordIndex1)->style;
+   bool drawHyphen = wordIndex2 == line->lastWord
+      && words->getRef(wordIndex2)->hyphenWidth > 0;
+
+   if (wordIndex1 == wordIndex2 && !drawHyphen) {
+      // Simple case, where copying in one buffer is not needed.
+      Word *word = words->getRef (wordIndex1);
+      drawWord0 (wordIndex1, wordIndex2, word->content.text, word->size.width,
+                 style, view, area, xWidget, yWidgetBase);
+   } else {
+      // Concaternate all words in a new buffer.
+      int l = 0, totalWidth = 0;
+      for (int i = wordIndex1; i <= wordIndex2; i++) {
+         Word *w = words->getRef (i);
+         l += strlen (w->content.text);
+         totalWidth += w->size.width;
+      }
+      
+      char text[l + (drawHyphen ? 2 : 0) + 1];
+      int p = 0;
+      for (int i = wordIndex1; i <= wordIndex2; i++) {
+         const char * t = words->getRef(i)->content.text;
+         strcpy (text + p, t);
+         p += strlen (t);
+      }
+
+      if(drawHyphen) {
+         text[p++] = 0xc2;
+         text[p++] = 0xad;
+         text[p++] = 0;
+      }
+      
+      drawWord0 (wordIndex1, wordIndex2, text, totalWidth,
+                 style, view, area, xWidget, yWidgetBase);
+   }
+}
+
+/**
+ * TODO Comment
+ */
+void Textblock::drawWord0 (int wordIndex1, int wordIndex2,
+                           const char *text, int totalWidth,
+                           core::style::Style *style, core::View *view,
+                           core::Rectangle *area, int xWidget, int yWidgetBase)
+{      
    int xWorld = allocation.x + xWidget;
-   core::style::Style *style = word->style;
    int yWorldBase;
 
    /* Adjust the text baseline if the word is <SUP>-ed or <SUB>-ed. */
@@ -1333,33 +920,33 @@ void Textblock::drawWord(int wordIndex, core::View *view,core::Rectangle *area,
    yWorldBase = yWidgetBase + allocation.y;
 
    drawText (view, style, core::style::Color::SHADING_NORMAL, xWorld,
-             yWorldBase, word->content.text, 0, strlen (word->content.text));
+             yWorldBase, text, 0, strlen (text));
 
    if (style->textDecoration)
       decorateText(view, style, core::style::Color::SHADING_NORMAL, xWorld,
-                   yWorldBase, word->size.width);
+                   yWorldBase, totalWidth);
 
    for (int layer = 0; layer < core::HIGHLIGHT_NUM_LAYERS; layer++) {
-      if (hlStart[layer].index <= wordIndex &&
-          hlEnd[layer].index >= wordIndex) {
-         const int wordLen = strlen (word->content.text);
+      if (hlStart[layer].index <= wordIndex1 &&
+          hlEnd[layer].index >= wordIndex2) {
+         const int wordLen = strlen (text);
          int xStart, width;
          int firstCharIdx = 0;
          int lastCharIdx = wordLen;
 
-         if (wordIndex == hlStart[layer].index)
+         if (wordIndex1 == hlStart[layer].index)
             firstCharIdx = misc::min (hlStart[layer].nChar, wordLen);
 
-         if (wordIndex == hlEnd[layer].index)
+         if (wordIndex2 == hlEnd[layer].index)
             lastCharIdx = misc::min (hlEnd[layer].nChar, wordLen);
 
          xStart = xWorld;
          if (firstCharIdx)
-            xStart += textWidth (word->content.text, 0, firstCharIdx, style);
+            xStart += textWidth (text, 0, firstCharIdx, style);
          if (firstCharIdx == 0 && lastCharIdx == wordLen)
-            width = word->size.width;
+            width = totalWidth;
          else
-            width = textWidth (word->content.text, firstCharIdx,
+            width = textWidth (text, firstCharIdx,
                                lastCharIdx - firstCharIdx, style);
          if (width > 0) {
             /* Highlight text */
@@ -1376,7 +963,7 @@ void Textblock::drawWord(int wordIndex, core::View *view,core::Rectangle *area,
 
             /* Highlight the text. */
             drawText (view, style, core::style::Color::SHADING_INVERSE, xStart,
-                      yWorldBase, word->content.text, firstCharIdx,
+                      yWorldBase, text, firstCharIdx,
                       lastCharIdx - firstCharIdx);
 
             if (style->textDecoration)
@@ -1445,18 +1032,12 @@ void Textblock::drawLine (Line *line, core::View *view, core::Rectangle *area)
    int xWidget = lineXOffsetWidget(line);
    int yWidgetBase = lineYOffsetWidget (line) + line->boxAscent;
 
-   /* Here's an idea on how to optimize this routine to minimize the number
-    * of drawing calls:
-    *
-    * Copy the text from the words into a buffer, adding a new word
-    * only if: the attributes match, and the spacing is either zero or
-    * equal to the width of ' '. In the latter case, copy a " " into
-    * the buffer. Then draw the buffer. */
-
    for (int wordIndex = line->firstWord;
-        wordIndex <= line->lastWord && xWidget < area->x + area->width;
+        wordIndex <= line->lastWord
+           /* TODO && xWidget < area->x + area->width*/;
         wordIndex++) {
       Word *word = words->getRef(wordIndex);
+      int wordSize = word->size.width;
 
       if (xWidget + word->size.width + word->effSpace >= area->x) {
          if (word->content.type == core::Content::TEXT ||
@@ -1470,12 +1051,26 @@ void Textblock::drawLine (Line *line, core::View *view, core::Rectangle *area)
                   if (child->intersects (area, &childArea))
                      child->draw (view, &childArea);
                } else {
+                  /* TODO: include in drawWord:
                   if (word->style->hasBackground ()) {
                      drawBox (view, word->style, area, xWidget,
                               yWidgetBase - line->boxAscent, word->size.width,
                               line->boxAscent + line->boxDescent, false);
-                  }
-                  drawWord(wordIndex, view, area, xWidget, yWidgetBase);
+                  }*/
+                  int wordIndex2 = wordIndex;
+                  while (wordIndex2 < line->lastWord &&
+                         words->getRef(wordIndex2)->hyphenWidth > 0 &&
+                         word->style == words->getRef(wordIndex2 + 1)->style)
+                     wordIndex2++;
+
+                  drawWord(line, wordIndex, wordIndex2, view, area,
+                           xWidget, yWidgetBase);
+                  wordSize = 0;
+                  for (int i = wordIndex; i <= wordIndex2; i++)
+                     wordSize += words->getRef(i)->size.width;
+
+                  wordIndex = wordIndex2;
+                  word = words->getRef(wordIndex);
                }
             }
             if (word->effSpace > 0 && wordIndex < line->lastWord &&
@@ -1492,7 +1087,7 @@ void Textblock::drawLine (Line *line, core::View *view, core::Rectangle *area)
 
          }
       }
-      xWidget += word->size.width + word->effSpace;
+      xWidget += wordSize + word->effSpace;
    }
 }
 
@@ -1599,6 +1194,9 @@ Textblock::Word *Textblock::findWord (int x, int y, bool *inSpace)
 
 void Textblock::draw (core::View *view, core::Rectangle *area)
 {
+   PRINTF ("DRAW: %d, %d, %d x %d\n",
+           area->x, area->y, area->width, area->height);
+
    int lineIndex;
    Line *line;
 
@@ -1629,10 +1227,11 @@ Textblock::Word *Textblock::addWord (int width, int ascent, int descent,
    word->size.width = width;
    word->size.ascent = ascent;
    word->size.descent = descent;
-   word->origSpace = 0;
-   word->effSpace = 0;
+   word->origSpace = word->effSpace = word->stretchability =
+      word->shrinkability = 0;
+   word->hyphenWidth = 0;
+   word->badnessAndPenalty.setPenaltyProhibitBreak ();
    word->content.space = false;
-   word->content.breakType = core::Content::BREAK_NO;
 
    //DBG_OBJ_ARRSET_NUM (this, "words.%d.size.width", words->size() - 1,
    //                    word->size.width);
@@ -1649,6 +1248,8 @@ Textblock::Word *Textblock::addWord (int width, int ascent, int descent,
 
    word->style = style;
    word->spaceStyle = style;
+   word->hyphenStyle = style;
+   style->ref ();
    style->ref ();
    style->ref ();
 
@@ -1765,23 +1366,119 @@ void Textblock::calcTextSize (const char *text, size_t len,
 
 
 /**
- * Add a word to the page structure.
+ * Add a word to the page structure. If it contains soft hyphens, it is
+ * divided.
  */
 void Textblock::addText (const char *text, size_t len,
                          core::style::Style *style)
 {
+   // Count hyphens.
+   int numHyphens = 0;
+   for (size_t i = 0; i < len - 1; i++)
+      // (0xc2, 0xad) is the UTF-8 representation of a soft hyphen (Unicode
+      // 0xc2).
+      if((unsigned char)text[i] == 0xc2 && (unsigned char)text[i + 1] == 0xad)
+         numHyphens++;
+
+   if (numHyphens == 0) {
+      // Simple (and often) case: no soft hyphens.
+      core::Requisition size;
+      calcTextSize (text, len, style, &size);
+      addText0 (text, len, style, &size);
+   } else {
+      PRINTF("HYPHENATION: '");
+      for (size_t i = 0; i < len; i++)
+         PUTCHAR(text[i]);
+      PRINTF("', with %d hyphen(s)\n", numHyphens);
+
+      // Store hyphen positions.
+      int n = 0, hyphenPos[numHyphens];
+      for (size_t i = 0; i < len - 1; i++)
+         if((unsigned char)text[i] == 0xc2 &&
+            (unsigned char)text[i + 1] == 0xad)
+            hyphenPos[n++] = i;
+
+      // Get text without hyphens. (There are numHyphens + 1 parts in the word,
+      // and 2 * numHyphens bytes less, 2 for each hyphen, are needed.)
+      char textWithoutHyphens[len - 2 * numHyphens];
+      int start = 0; // related to "text"
+      for (int i = 0; i < numHyphens + 1; i++) {
+         int end = (i == numHyphens) ? len : hyphenPos[i];
+         memmove (textWithoutHyphens + start - 2 * i, text + start,
+                  end - start);
+         start = end + 2;
+      }
+
+      PRINTF("H... without hyphens: '");
+      for (size_t i = 0; i < len - 2 * numHyphens; i++)
+         PUTCHAR(textWithoutHyphens[i]);
+      PRINTF("'\n");
+
+      // Calc sizes.
+      core::Requisition wordSize[numHyphens + 1];
+
+      // The size of the last part is calculated in a simple way.
+      int lastStart = hyphenPos[numHyphens - 1] + 2;
+      calcTextSize (text + lastStart, len - lastStart, style,
+                    &wordSize[numHyphens]);
+
+      PRINTF("H... [%d] '", numHyphens);
+      for (size_t i = 0; i < len - lastStart; i++)
+         PUTCHAR(text[i + lastStart]);
+      PRINTF("' -> %d\n", wordSize[numHyphens].width);
+      
+      // The rest is more complicated. TODO Documentation.
+      for (int i = numHyphens - 1; i >= 0; i--) {
+         int start = (i == 0) ? 0 : hyphenPos[i - 1] - 2 * (i - 1);
+         calcTextSize (textWithoutHyphens + start,
+                       len - 2 * numHyphens - start, style, &wordSize[i]);
+
+         PRINTF("H... [%d] '", i);
+         for (size_t j = 0; j < len - 2 * numHyphens - start; j++)
+            PUTCHAR(textWithoutHyphens[j + start]);
+         PRINTF("' -> %d\n", wordSize[i].width);
+
+         for (int j = i + 1; j < numHyphens + 1; j++) {
+            wordSize[i].width -= wordSize[j].width;
+            PRINTF("H...    - %d = %d\n", wordSize[j].width, wordSize[i].width);
+         }
+      }
+ 
+      // Finished!
+      for (int i = 0; i < numHyphens + 1; i++) {
+         int start = (i == 0) ? 0 : hyphenPos[i - 1] + 2;
+         int end = (i == numHyphens) ? len : hyphenPos[i];
+         addText0 (text + start, end - start, style, &wordSize[i]);
+
+         PRINTF("H... [%d] '", i);
+         for (int j = start; j < end; j++)
+            PUTCHAR(text[j]);
+         PRINTF("' added\n");
+
+         if(i < numHyphens) {
+            addHyphen (style);
+            PRINTF("H... yphen added\n");
+         }
+      }
+   }
+}
+
+/**
+ * Add a word (without hyphens) to the page structure.
+ */
+void Textblock::addText0 (const char *text, size_t len,
+                          core::style::Style *style, core::Requisition *size)
+{
    Word *word;
-   core::Requisition size;
 
-   calcTextSize (text, len, style, &size);
-   word = addWord (size.width, size.ascent, size.descent, style);
+   word = addWord (size->width, size->ascent, size->descent, style);
    word->content.type = core::Content::TEXT;
    word->content.text = layout->textZone->strndup(text, len);
 
    //DBG_OBJ_ARRSET_STR (page, "words.%d.content.text", words->size() - 1,
    //                    word->content.text);
 
-   wordWrap (words->size () - 1);
+   wordWrap (words->size () - 1, false);
 }
 
 /**
@@ -1798,6 +1495,8 @@ void Textblock::addWidget (core::Widget *widget, core::style::Style *style)
     * end of this function, the correct value is assigned. */
    widget->parentRef = -1;
 
+   PRINTF("%p becomes child of %p\n", widget, this);
+   
    widget->setParent (this);
    widget->setStyle (style);
 
@@ -1810,8 +1509,7 @@ void Textblock::addWidget (core::Widget *widget, core::style::Style *style)
    //DBG_OBJ_ARRSET_PTR (page, "words.%d.content.widget", words->size() - 1,
    //                    word->content.widget);
 
-   wordWrap (words->size () - 1);
-   word->content.widget->parentRef = lines->size () - 1;
+   wordWrap (words->size () - 1, false);
    //DBG_OBJ_SET_NUM (word->content.widget, "parent_ref",
    //                 word->content.widget->parent_ref);
 
@@ -1879,11 +1577,17 @@ void Textblock::addSpace (core::style::Style *style)
       // This is important e.g. to be able to break between foo and bar in:
       // <span style="white-space:nowrap">foo </span> bar
       addBreakOption (style);
- 
+
       if (!word->content.space) {
+         word->badnessAndPenalty.setPenalty (0);
          word->content.space = true;
          word->effSpace = word->origSpace = style->font->spaceWidth +
                                             style->wordSpacing;
+         word->stretchability = word->origSpace / 2;
+         if(style->textAlign == core::style::TEXT_ALIGN_JUSTIFY)
+            word->shrinkability = word->origSpace / 3;
+         else
+            word->shrinkability = 0;
 
          //DBG_OBJ_ARRSET_NUM (this, "words.%d.origSpace", wordIndex,
          //                    word->origSpace);
@@ -1891,13 +1595,36 @@ void Textblock::addSpace (core::style::Style *style)
          //                    word->effSpace);
          //DBG_OBJ_ARRSET_NUM (this, "words.%d.content.space", wordIndex,
          //                    word->content.space);
+
          word->spaceStyle->unref ();
          word->spaceStyle = style;
          style->ref ();
+
+         accumulateWordData (wordIndex);
       }
    }
 }
 
+void Textblock::addHyphen (core::style::Style *style)
+{
+   int wordIndex = words->size () - 1;
+
+   if (wordIndex >= 0) {
+      Word *word = words->getRef(wordIndex);
+ 
+      word->badnessAndPenalty.setPenalty (HYPHEN_BREAK);
+      //word->penalty = 0;
+      // TODO Optimize? Like spaces?
+      word->hyphenWidth = layout->textWidth (style->font, "\xc2\xad", 2);
+
+      word->hyphenStyle->unref ();
+      word->hyphenStyle = style;
+      style->ref ();
+
+      accumulateWordData (wordIndex);
+   }
+}
+
 /**
  * Cause a paragraph break
  */
@@ -1969,8 +1696,9 @@ void Textblock::addParbreak (int space, core::style::Style *style)
 
    word = addWord (0, 0, 0, style);
    word->content.type = core::Content::BREAK;
+   word->badnessAndPenalty.setPenaltyForceBreak ();
    word->content.breakSpace = space;
-   wordWrap (words->size () - 1);
+   wordWrap (words->size () - 1, false);
 }
 
 /*
@@ -1990,8 +1718,9 @@ void Textblock::addLinebreak (core::style::Style *style)
       word = addWord (0, 0, 0, style);
 
    word->content.type = core::Content::BREAK;
+   word->badnessAndPenalty.setPenaltyForceBreak ();
    word->content.breakSpace = 0;
-   wordWrap (words->size () - 1);
+   wordWrap (words->size () - 1, false);
 }
 
 
@@ -2064,6 +1793,9 @@ void Textblock::handOverBreak (core::style::Style *style)
  */
 void Textblock::flush ()
 {
+   PRINTF ("[%p] FLUSH => %s (parentRef = %d)\n",
+           this, mustQueueResize ? "true" : "false", parentRef);
+
    if (mustQueueResize) {
       queueResize (-1, true);
       mustQueueResize = false;
diff --git a/dw/textblock.hh b/dw/textblock.hh
index 3f98f878..b301db7d 100644
--- a/dw/textblock.hh
+++ b/dw/textblock.hh
@@ -1,15 +1,27 @@
 #ifndef __DW_TEXTBLOCK_HH__
 #define __DW_TEXTBLOCK_HH__
 
+#include <limits.h>
+
 #include "core.hh"
 #include "../lout/misc.hh"
 
+// These were used when improved line breaking and hyphenation were
+// implemented. Should be cleaned up; perhaps reactivate RTFL again.
+#define PRINTF(fmt, ...)
+#define PUTCHAR(ch)
+
 namespace dw {
 
 /**
  * \brief A Widget for rendering text blocks, i.e. paragraphs or sequences
  *    of paragraphs.
  *
+ * <div style="border: 2px solid #ff0000; padding: 0.5em 1em;
+ * background-color: #ffe0e0"><b>Warning:</b> The recent changes (line
+ * breaking and hyphenation) have not yet been incorporated into this
+ * documentation. See \ref dw-line-breaking.</div>
+ *
  * <h3>Signals</h3>
  *
  * dw::Textblock uses the signals defined in
@@ -130,7 +142,50 @@ namespace dw {
  */
 class Textblock: public core::Widget
 {
+private:
+   /**
+    * This class encapsulates the badness/penalty calculation, and so
+    * (i) makes changes (hopefully) simpler, and (ii) hides the
+    * integer arithmetics (floating point arithmetics avoided for
+    * performance reasons). Unfortunately, the value range of the
+    * badness is not well defined, so fiddling with the penalties is a
+    * bit difficult.
+    */
+   class BadnessAndPenalty
+   {
+   private:
+      enum { TOO_LOOSE, TOO_TIGHT, BADNESS_VALUE } badnessState;
+      enum { FORCE_BREAK, PROHIBIT_BREAK, PENALTY_VALUE } penaltyState;
+      int badness, penalty;
+      
+      // for debugging:
+      int totalWidth, idealWidth, totalStretchability, totalShrinkability;
+
+      int badnessInfinities ();
+      int penaltyInfinities ();
+      int badnessValue ();
+      int penaltyValue ();
+      
+   public:
+      void calcBadness (int totalWidth, int idealWidth,
+                        int totalStretchability, int totalShrinkability);
+      void setPenalty (int penalty);
+      void setPenaltyProhibitBreak ();
+      void setPenaltyForceBreak ();
+
+      bool lineTooTight ();
+      bool lineMustBeBroken ();
+      bool lineCanBeBroken ();
+      int compareTo (BadnessAndPenalty *other);
+
+      void print ();
+   };
+
 protected:
+   enum {
+      HYPHEN_BREAK = 1000000 // to be tested and tuned
+   };
+
    struct Line
    {
       int firstWord;    /* first word's index in word vector */
@@ -150,9 +205,10 @@ protected:
       int maxLineWidth; /* maximum of all line widths */
       int maxParMin;    /* maximum of all paragraph minima */
       int maxParMax;    /* maximum of all paragraph maxima */
-      int parMax;       /* the maximal total width down from the last
-                         * paragraph start, to the *beginning* of the
-                         * line */
+      int parMax;       /* The maximal total width down from the last
+                         * paragraph start, to the *ene* of this
+                         * line. (Notice that the semantics have
+                         * changed.) */
    };
 
    struct Word
@@ -161,13 +217,35 @@ protected:
       core::Requisition size;
       /* Space after the word, only if it's not a break: */
       short origSpace; /* from font, set by addSpace */
+      short stretchability, shrinkability;
       short effSpace;  /* effective space, set by wordWrap,
                         * used for drawing etc. */
+      short hyphenWidth; /* Additional width, when a word is part
+                          * (except the last part) of a hyphenationed
+                          * word. Has to be added to the width, when
+                          * this is the last word of the line, and
+                          * "hyphenWidth > 0" is also used to decide
+                          * weather to draw a hyphen. */
       core::Content content;
 
+      // accumulated values, relative to the beginning of the line
+      int totalWidth;          /* The sum of all word widths; plus all
+                                  spaces, excluding the one of this
+                                  word; plus the hypthen width of this
+                                  word (but of course, no hyphen
+                                  widths of previous words. In other
+                                  words: the value compared to the
+                                  ideal width of the line, if the line
+                                  would be broken after this word. */
+      int totalStretchability; // includes all *before* current word
+      int totalShrinkability;  // includes all *before* current word
+      BadnessAndPenalty badnessAndPenalty; /* when line is broken after this
+                                            * word */
+
       core::style::Style *style;
       core::style::Style *spaceStyle; /* initially the same as of the word,
                                          later set by a_Dw_page_add_space */
+      core::style::Style *hyphenStyle;
    };
 
    struct Anchor
@@ -236,13 +314,10 @@ protected:
    /* These values are set by set_... */
    int availWidth, availAscent, availDescent;
 
-   int lastLineWidth;
-   int lastLineParMin; /* width of the current non-breakable word sequence
-                        * used by wordWrap () */
-   int lastLineParMax;
    int wrapRef;  /* [0 based] */
 
    lout::misc::SimpleVector <Line> *lines;
+   int nonTemporaryLines;
    lout::misc::SimpleVector <Word> *words;
    lout::misc::SimpleVector <Anchor> *anchors;
 
@@ -254,25 +329,28 @@ protected:
 
    void queueDrawRange (int index1, int index2);
    void getWordExtremes (Word *word, core::Extremes *extremes);
-   inline bool canBreakAfter (Word *word)
-   {
-      return word->content.breakType == core::Content::BREAK_OK;
-   }
    void markChange (int ref);
-   void justifyLine (Line *line, int availWidth);
-   Line *addLine (int wordInd, bool newPar);
+   void justifyLine (Line *line, int diff);
+   Line *addLine (int firstWord, int lastWord, bool temporary);
    void calcWidgetSize (core::Widget *widget, core::Requisition *size);
    void rewrap ();
-   void decorateText(core::View *view, core::style::Style *style,
-                     core::style::Color::Shading shading,
-                     int x, int yBase, int width);
-   void drawText(core::View *view, core::style::Style *style,
-                 core::style::Color::Shading shading, int x, int y,
-                 const char *text, int start, int len);
-   void drawWord(int wordIndex, core::View *view, core::Rectangle *area,
-                 int xWidget, int yWidgetBase);
-   void drawSpace(int wordIndex, core::View *view, core::Rectangle *area,
-                  int xWidget, int yWidgetBase);
+   void showMissingLines ();
+   void removeTemporaryLines ();
+
+   void decorateText (core::View *view, core::style::Style *style,
+                      core::style::Color::Shading shading,
+                      int x, int yBase, int width);
+   void drawText (core::View *view, core::style::Style *style,
+                  core::style::Color::Shading shading, int x, int y,
+                  const char *text, int start, int len);
+   void drawWord (Line *line, int wordIndex1, int wordIndex2, core::View *view,
+                  core::Rectangle *area, int xWidget, int yWidgetBase);
+   void drawWord0 (int wordIndex1, int wordIndex2,
+                   const char *text, int totalWidth,
+                   core::style::Style *style, core::View *view,
+                   core::Rectangle *area, int xWidget, int yWidgetBase);
+   void drawSpace (int wordIndex, core::View *view, core::Rectangle *area,
+                   int xWidget, int yWidgetBase);
    void drawLine (Line *line, core::View *view, core::Rectangle *area);
    int findLineIndex (int y);
    int findLineOfWord (int wordIndex);
@@ -348,7 +426,14 @@ protected:
    bool sendSelectionEvent (core::SelectionState::EventType eventType,
                             core::MousePositionEvent *event);
 
-   virtual void wordWrap(int wordIndex);
+   void accumulateWordExtremees (int firstWord, int lastWord,
+                                 int *maxOfMinWidth, int *sumOfMaxWidth);
+   virtual void wordWrap (int wordIndex, bool wrapAll);
+   void accumulateWordForLine (int lineIndex, int wordIndex);
+   void accumulateWordData(int wordIndex);
+   int calcAvailWidth ();
+   void initLine1Offset (int wordIndex);
+   void alignLine (Line *line);
 
    void sizeRequestImpl (core::Requisition *requisition);
    void getExtremesImpl (core::Extremes *extremes);
@@ -370,6 +455,9 @@ protected:
 
    void removeChild (Widget *child);
 
+   void addText0 (const char *text, size_t len, core::style::Style *style,
+                  core::Requisition *size);
+
 public:
    static int CLASS_ID;
 
@@ -388,14 +476,16 @@ public:
    void addWidget (core::Widget *widget, core::style::Style *style);
    bool addAnchor (const char *name, core::style::Style *style);
    void addSpace(core::style::Style *style);
-   inline void addBreakOption (core::style::Style *style)
+   inline void addBreakOption (core::style::Style *style) // TODO needed?
    {
       int wordIndex = words->size () - 1;
       if (wordIndex >= 0 &&
           style->whiteSpace != core::style::WHITE_SPACE_NOWRAP &&
           style->whiteSpace != core::style::WHITE_SPACE_PRE)
-         words->getRef(wordIndex)->content.breakType = core::Content::BREAK_OK;
+         words->getRef(wordIndex)->badnessAndPenalty.setPenaltyForceBreak ();
    }
+
+   void addHyphen(core::style::Style *style);
    void addParbreak (int space, core::style::Style *style);
    void addLinebreak (core::style::Style *style);
 
diff --git a/dw/textblock_linebreaking.cc b/dw/textblock_linebreaking.cc
new file mode 100644
index 00000000..7037330e
--- /dev/null
+++ b/dw/textblock_linebreaking.cc
@@ -0,0 +1,688 @@
+#include "textblock.hh"
+#include "../lout/msg.h"
+#include "../lout/misc.hh"
+
+#include <stdio.h>
+#include <math.h>
+
+using namespace lout;
+
+namespace dw {
+
+int Textblock::BadnessAndPenalty::badnessInfinities ()
+{
+   switch (badnessState) {
+   case TOO_LOOSE:
+   case TOO_TIGHT:
+      return 1;
+
+   case BADNESS_VALUE:
+      return 0;
+   }
+
+   // compiler happiness
+   lout::misc::assertNotReached ();
+   return 0;
+}
+
+int Textblock::BadnessAndPenalty::penaltyInfinities ()
+{
+   switch (penaltyState) {
+   case FORCE_BREAK:
+      return -1;
+
+   case PROHIBIT_BREAK:
+      return 1;
+
+   case PENALTY_VALUE:
+      return 0;
+   }
+
+   // compiler happiness
+   lout::misc::assertNotReached ();
+   return 0;
+}
+
+int Textblock::BadnessAndPenalty::badnessValue ()
+{
+   return badnessState == BADNESS_VALUE ? badness : 0;
+}
+
+int Textblock::BadnessAndPenalty::penaltyValue ()
+{
+   return penaltyState == PENALTY_VALUE ? penalty : 0;
+}
+
+void Textblock::BadnessAndPenalty::calcBadness (int totalWidth, int idealWidth,
+                                                int totalStretchability,
+                                                int totalShrinkability)
+{
+   this->totalWidth = totalWidth;
+   this->idealWidth = idealWidth;
+   this->totalStretchability = totalStretchability;
+   this->totalShrinkability = totalShrinkability;
+
+   if (totalWidth == idealWidth) {
+      badnessState = BADNESS_VALUE;
+      badness = 0;
+   } else if (totalWidth < idealWidth) {
+      if (totalStretchability == 0)
+         badnessState = TOO_LOOSE;
+      else {
+         int ratio = 100 * (idealWidth - totalWidth) / totalStretchability;
+         if (ratio > 1024)
+            badnessState = TOO_LOOSE;
+         else {
+            badnessState = BADNESS_VALUE;
+            badness = ratio * ratio * ratio;
+         }
+      }
+   } else { // if (word->totalWidth > availWidth)
+      if (totalShrinkability == 0)
+         badnessState = TOO_TIGHT;
+      else {
+         // Important: ratio is positive here.
+         int ratio = 100 * (totalWidth - idealWidth) / totalShrinkability;
+         if (ratio >= 100)
+            badnessState = TOO_TIGHT;
+         else {
+            badnessState = BADNESS_VALUE;
+            badness = ratio * ratio * ratio;
+         }
+      }
+   }
+}
+
+void Textblock::BadnessAndPenalty::setPenalty (int penalty)
+{
+   this->penalty = penalty;
+   penaltyState = PENALTY_VALUE;
+}
+
+void Textblock::BadnessAndPenalty::setPenaltyProhibitBreak ()
+{
+   penaltyState = PROHIBIT_BREAK;
+}
+
+void Textblock::BadnessAndPenalty::setPenaltyForceBreak ()
+{
+   penaltyState = FORCE_BREAK;
+}
+
+bool Textblock::BadnessAndPenalty::lineTooTight ()
+{
+   return badnessState == TOO_TIGHT;
+}
+
+bool Textblock::BadnessAndPenalty::lineMustBeBroken ()
+{
+   return penaltyState == FORCE_BREAK;
+}
+
+bool Textblock::BadnessAndPenalty::lineCanBeBroken ()
+{
+   return penaltyState != PROHIBIT_BREAK;
+}
+
+int Textblock::BadnessAndPenalty::compareTo (BadnessAndPenalty *other)
+{
+   int thisNumInfinities = badnessInfinities () + penaltyInfinities ();
+   int otherNumInfinities =
+      other->badnessInfinities () + other->penaltyInfinities ();
+   int thisValue = badnessValue () + penaltyValue ();
+   int otherValue = other->badnessValue () + other->penaltyValue ();
+
+   if (thisNumInfinities == otherNumInfinities)
+      return thisValue - otherValue;
+   else
+      return thisNumInfinities - otherNumInfinities;
+}
+
+void Textblock::BadnessAndPenalty::print ()
+{
+   switch (badnessState) {
+   case TOO_LOOSE:
+      PRINTF ("loose");
+      break;
+
+   case TOO_TIGHT:
+      PRINTF ("tight");
+      break;
+
+   case BADNESS_VALUE:
+      PRINTF ("%d", badness);
+      break;
+   }
+
+   PRINTF (" [%d + %d - %d vs. %d] + ", totalWidth, totalStretchability,
+           totalShrinkability, idealWidth);
+
+   switch (penaltyState) {
+   case FORCE_BREAK:
+      PRINTF ("-inf");
+      break;
+
+   case PROHIBIT_BREAK:
+      PRINTF ("inf");
+      break;
+
+   case PENALTY_VALUE:
+      PRINTF ("%d", penalty);
+      break;
+   }
+}
+
+/*
+ * ...
+ *
+ * diff ...
+ */
+void Textblock::justifyLine (Line *line, int diff)
+{
+   /* To avoid rounding errors, the calculation is based on accumulated
+    * values. */
+
+   if (diff > 0) {
+      int stretchabilitySum = 0;
+      for (int i = line->firstWord; i < line->lastWord; i++)
+         stretchabilitySum += words->getRef(i)->stretchability;
+
+      if (stretchabilitySum > 0) {
+         int stretchabilityCum = 0;
+         int spaceDiffCum = 0;
+         for (int i = line->firstWord; i < line->lastWord; i++) {
+            Word *word = words->getRef (i);
+            stretchabilityCum += word->stretchability;
+            int spaceDiff =
+               stretchabilityCum * diff / stretchabilitySum - spaceDiffCum;
+            spaceDiffCum += spaceDiff;
+
+            PRINTF ("         %d (of %d): diff = %d\n", i, words->size (),
+                    spaceDiff);
+
+            word->effSpace = word->origSpace + spaceDiff;
+         }
+      }
+   } else if (diff < 0) {
+      int shrinkabilitySum = 0;
+      for (int i = line->firstWord; i < line->lastWord; i++)
+         shrinkabilitySum += words->getRef(i)->shrinkability;
+
+      if (shrinkabilitySum > 0) {
+         int shrinkabilityCum = 0;
+         int spaceDiffCum = 0;
+         for (int i = line->firstWord; i < line->lastWord; i++) {
+            Word *word = words->getRef (i);
+            shrinkabilityCum += word->shrinkability;
+            int spaceDiff =
+               shrinkabilityCum * diff / shrinkabilitySum - spaceDiffCum;
+            spaceDiffCum += spaceDiff;
+
+            word->effSpace = word->origSpace + spaceDiff;
+         }
+      }
+   }
+}
+
+
+Textblock::Line *Textblock::addLine (int firstWord, int lastWord,
+                                     bool temporary)
+{
+   PRINTF ("[%p] ADD_LINE (%d, %d)\n", this, firstWord, lastWord);
+
+   Word *lastWordOfLine = words->getRef(lastWord);
+   // Word::totalWidth includes the hyphen (which is what we want here).
+   int lineWidth = lastWordOfLine->totalWidth;
+   int maxOfMinWidth, sumOfMaxWidth;
+   accumulateWordExtremees (firstWord, lastWord, &maxOfMinWidth,
+                            &sumOfMaxWidth);
+
+   PRINTF ("   words[%d]->totalWidth = %d\n", lastWord,
+           lastWordOfLine->totalWidth);
+
+   lines->increase ();
+   if(!temporary) {
+      // If the last line was temporary, this will be temporary, too, even
+      // if not requested.
+      if (lines->size () == 1 || nonTemporaryLines == lines->size () -1)
+         nonTemporaryLines = lines->size ();
+   }
+
+   PRINTF ("nonTemporaryLines = %d\n", nonTemporaryLines);
+
+   int lineIndex = lines->size () - 1;
+   Line *line = lines->getRef (lineIndex);
+
+   line->firstWord = firstWord;
+   line->lastWord = lastWord;
+   line->boxAscent = line->contentAscent = 0;
+   line->boxDescent = line->contentDescent = 0;
+   line->marginDescent = 0;
+   line->breakSpace = 0;
+   line->leftOffset = 0;
+
+   if (lines->size () == 1) {
+      line->top = 0;
+
+      // TODO What to do with this one: lastLine->maxLineWidth = line1OffsetEff;
+      line->maxLineWidth = lineWidth;
+      line->maxParMin = maxOfMinWidth;
+      line->parMax = line->maxParMax = sumOfMaxWidth;
+   } else {
+      Line *prevLine = lines->getRef (lines->size () - 2);
+
+      line->top = prevLine->top + prevLine->boxAscent +
+         prevLine->boxDescent + prevLine->breakSpace;
+
+      line->maxLineWidth = misc::max (lineWidth, prevLine->maxLineWidth);
+      line->maxParMin = misc::max (maxOfMinWidth, prevLine->maxParMin);
+
+      Word *lastWordOfPrevLine = words->getRef (prevLine->lastWord);
+      if (lastWordOfPrevLine->content.type == core::Content::BREAK)
+         // This line starts a new paragraph.
+         line->parMax = sumOfMaxWidth;
+      else
+         // This line continues the paragraph from prevLine.
+         line->parMax = prevLine->parMax + sumOfMaxWidth;
+
+      line->maxParMax = misc::max (line->parMax, prevLine->maxParMax);
+
+   }
+   
+   for(int i = line->firstWord; i <= line->lastWord; i++)
+      accumulateWordForLine (lineIndex, i);
+
+   PRINTF ("   line[%d].top = %d\n", lines->size () - 1, line->top);
+   PRINTF ("   line[%d].boxAscent = %d\n", lines->size () - 1, line->boxAscent);
+   PRINTF ("   line[%d].boxDescent = %d\n",
+           lines->size () - 1, line->boxDescent);
+   PRINTF ("   line[%d].contentAscent = %d\n", lines->size () - 1,
+           line->contentAscent);
+   PRINTF ("   line[%d].contentDescent = %d\n",
+           lines->size () - 1, line->contentDescent);
+
+   alignLine (line);
+   mustQueueResize = true;
+
+   return line;
+}
+
+void Textblock::accumulateWordExtremees (int firstWord, int lastWord,
+                                         int *maxOfMinWidth, int *sumOfMaxWidth)
+{
+   *maxOfMinWidth = *sumOfMaxWidth = 0;
+
+   for (int i = firstWord; i <= lastWord; i++) {
+      Word *word = words->getRef (i);
+      core::Extremes extremes;
+      getWordExtremes (word, &extremes);
+
+      *maxOfMinWidth = misc::min (*maxOfMinWidth, extremes.minWidth);
+      *sumOfMaxWidth += (extremes.maxWidth + word->origSpace);
+      // Regarding the sum: if this is the end of the paragraph, it
+      // does not matter, since word->space is 0 in this case.
+   }
+}
+
+/*
+ * This method is called in two cases: (i) when a word is added
+ * (ii) when a page has to be (partially) rewrapped. It does word wrap,
+ * and adds new lines if necessary.
+ */
+void Textblock::wordWrap (int wordIndex, bool wrapAll)
+{
+   Word *word;
+   //core::Extremes wordExtremes;
+
+   if (!wrapAll)
+      removeTemporaryLines ();
+
+   initLine1Offset (wordIndex);
+
+   word = words->getRef (wordIndex);
+   word->effSpace = word->origSpace;
+
+   accumulateWordData (wordIndex);
+
+   bool newLine;
+   do {
+      bool tempNewLine = false;
+      int firstIndex = lines->size() == 0 ?
+         0 : lines->getRef(lines->size() - 1)->lastWord + 1;
+      int searchUntil;
+
+      if (wrapAll && wordIndex >= firstIndex && wordIndex == words->size() -1) {
+         newLine = true;
+         searchUntil = wordIndex;
+         tempNewLine = true;
+         PRINTF ("NEW LINE: last word\n");
+      } else if (wordIndex >= firstIndex &&
+          word->badnessAndPenalty.lineMustBeBroken ()) {
+         newLine = true;
+         searchUntil = wordIndex;
+         PRINTF ("NEW LINE: forced break\n");
+      } else if (wordIndex > firstIndex &&
+                 word->badnessAndPenalty.lineTooTight () &&
+                 words->getRef(wordIndex- 1)
+                 ->badnessAndPenalty.lineCanBeBroken ()) {
+         // TODO Comment the last condition (also below where the minimun is
+         // searched for)
+         newLine = true;
+         searchUntil = wordIndex - 1;
+         PRINTF ("NEW LINE: line too tight\n");
+      } else
+         newLine = false;
+
+      if(newLine) {
+         PRINTF ("   searching from %d to %d\n", firstIndex, searchUntil);
+         
+         accumulateWordData (wordIndex);
+
+         int breakPos = -1;
+         for (int i = firstIndex; i <= searchUntil; i++) {
+            Word *w = words->getRef(i);
+
+            if(word->content.type && core::Content::REAL_CONTENT) {
+               PRINTF ("      %d (of %d): ", i, words->size ());
+
+               switch(w->content.type) {
+               case core::Content::TEXT:
+                  PRINTF ("\"%s\"", w->content.text);
+                  break;
+               case core::Content::WIDGET:
+                  PRINTF ("<widget: %p>\n", w->content.widget);
+                  break;
+               case core::Content::BREAK:
+                  PRINTF ("<break>\n");
+                  break;
+               default:
+                  PRINTF ("<?>\n");
+                  break;                 
+               }
+
+               PRINTF (" [%d / %d + %d - %d] => ",
+                       w->size.width, w->origSpace, w->stretchability,
+                       w->shrinkability);
+               w->badnessAndPenalty.print ();
+               PRINTF ("\n");
+            }
+            
+
+            // TODO: is this condition needed:
+            // if(w->badnessAndPenalty.lineCanBeBroken ()) ?
+
+            if (breakPos == -1 ||
+                w->badnessAndPenalty.compareTo
+                (&words->getRef(breakPos)->badnessAndPenalty) <= 0)
+               // "<=" instead of "<" in the next lines tends to result in more
+               // words per line -- theoretically. Practically, the case "=="
+               // will never occur.
+               breakPos = i;
+         }
+
+         if (wrapAll && searchUntil == words->size () - 1) {
+            // Since no break and no space is added, the last word
+            // will have a penalty of inf. Actually, it should be -inf,
+            // since it is the last word. However, since more words may
+            // follow, the penalty is not changesd, but here, the search
+            // is corrected (maybe only temporary).
+            Word *lastWord = words->getRef (searchUntil);
+            BadnessAndPenalty correctedBap = lastWord->badnessAndPenalty;
+            correctedBap.setPenaltyForceBreak ();
+            if (correctedBap.compareTo
+                (&words->getRef(breakPos)->badnessAndPenalty) <= 0)
+               breakPos = searchUntil;
+         }
+
+         PRINTF ("   new line from %d to %d\n", firstIndex, breakPos);
+         addLine (firstIndex, breakPos, tempNewLine);
+         PRINTF ("   accumulating again from %d to %d\n",
+                 breakPos + 1, wordIndex);
+
+         for(int i = breakPos + 1; i <= wordIndex; i++)
+            accumulateWordData (i);
+      }
+   } while (newLine);
+}
+
+void Textblock::accumulateWordForLine (int lineIndex, int wordIndex)
+{
+   Line *line = lines->getRef (lineIndex);
+   Word *word = words->getRef (wordIndex);
+
+   PRINTF ("      %d + %d / %d + %d\n", line->boxAscent, line->boxDescent,
+           word->size.ascent, word->size.descent);
+
+   line->boxAscent = misc::max (line->boxAscent, word->size.ascent);
+   line->boxDescent = misc::max (line->boxDescent, word->size.descent);
+
+   int len = word->style->font->ascent;
+   if (word->style->valign == core::style::VALIGN_SUPER)
+      len += len / 2;
+   line->contentAscent = misc::max (line->contentAscent, len);
+         
+   len = word->style->font->descent;
+   if (word->style->valign == core::style::VALIGN_SUB)
+      len += word->style->font->ascent / 3;
+   line->contentDescent = misc::max (line->contentDescent, len);
+
+   if (word->content.type == core::Content::WIDGET) {
+      int collapseMarginTop = 0;
+
+      line->marginDescent =
+         misc::max (line->marginDescent,
+                    word->size.descent +
+                    word->content.widget->getStyle()->margin.bottom);
+
+      if (lines->size () == 1 &&
+          word->content.widget->blockLevel () &&
+          getStyle ()->borderWidth.top == 0 &&
+          getStyle ()->padding.top == 0) {
+         // collapse top margins of parent element and its first child
+         // see: http://www.w3.org/TR/CSS21/box.html#collapsing-margins
+         collapseMarginTop = getStyle ()->margin.top;
+      }
+
+      line->boxAscent =
+            misc::max (line->boxAscent,
+                       word->size.ascent,
+                       word->size.ascent
+                       + word->content.widget->getStyle()->margin.top
+                       - collapseMarginTop);
+
+      word->content.widget->parentRef = lineIndex;
+   } else {
+      line->marginDescent =
+         misc::max (line->marginDescent, line->boxDescent);
+
+      if (word->content.type == core::Content::BREAK)
+         line->breakSpace =
+            misc::max (word->content.breakSpace,
+                       line->marginDescent - line->boxDescent,
+                       line->breakSpace);
+   }
+}
+
+void Textblock::accumulateWordData (int wordIndex)
+{
+   PRINTF ("[%p] ACCUMULATE_WORD_DATA: %d\n", this, wordIndex);
+
+   Word *word = words->getRef (wordIndex);
+   int availWidth = calcAvailWidth (); // todo: variable? parameter?
+
+   if (wordIndex == 0 ||
+       (lines->size () > 0 &&
+        wordIndex == lines->getRef(lines->size () - 1)->lastWord + 1)) {
+      // first word of the (not neccessarily yet existing) line
+      word->totalWidth = word->size.width;
+      word->totalStretchability = 0;
+      word->totalShrinkability = 0;
+   } else {
+      Word *prevWord = words->getRef (wordIndex - 1);
+
+      word->totalWidth = prevWord->totalWidth
+         + prevWord->origSpace - prevWord->hyphenWidth
+         + word->size.width + word->hyphenWidth;
+      word->totalStretchability =
+         prevWord->totalStretchability + prevWord->stretchability;
+      word->totalShrinkability =
+         prevWord->totalShrinkability + prevWord->shrinkability;
+   }
+
+   PRINTF("      line width: %d of %d\n", word->totalWidth, availWidth);
+   PRINTF("      spaces: + %d - %d\n",
+          word->totalStretchability, word->totalShrinkability);
+
+   word->badnessAndPenalty.calcBadness (word->totalWidth, availWidth,
+                                        word->totalStretchability,
+                                        word->totalShrinkability);
+}
+
+int Textblock::calcAvailWidth ()
+{
+   int availWidth =
+      this->availWidth - getStyle()->boxDiffWidth() - innerPadding;
+   if (limitTextWidth &&
+       layout->getUsesViewport () &&
+       availWidth > layout->getWidthViewport () - 10)
+      availWidth = layout->getWidthViewport () - 10;
+
+   //PRINTF("[%p] CALC_AVAIL_WIDTH => %d - %d - %d = %d\n",
+   //       this, this->availWidth, getStyle()->boxDiffWidth(), innerPadding,
+   //       availWidth);
+
+   return availWidth;
+}
+
+void Textblock::initLine1Offset (int wordIndex)
+{
+   Word *word = words->getRef (wordIndex);
+
+   /* Test whether line1Offset can be used. */
+   if (wordIndex == 0) {
+      if (ignoreLine1OffsetSometimes &&
+          line1Offset + word->size.width > availWidth) {
+         line1OffsetEff = 0;
+      } else {
+         int indent = 0;
+
+         if (word->content.type == core::Content::WIDGET &&
+             word->content.widget->blockLevel() == true) {
+            /* don't use text-indent when nesting blocks */
+         } else {
+            if (core::style::isPerLength(getStyle()->textIndent)) {
+               indent = misc::roundInt(this->availWidth *
+                        core::style::perLengthVal (getStyle()->textIndent));
+            } else {
+               indent = core::style::absLengthVal (getStyle()->textIndent);
+            }
+         }
+         line1OffsetEff = line1Offset + indent;
+      }
+   }
+}
+
+/**
+ * Align the line.
+ *
+ * \todo Use block's style instead once paragraphs become proper blocks.
+ */
+void Textblock::alignLine (Line *line)
+{
+   int availWidth = calcAvailWidth ();
+   Word *firstWord = words->getRef (line->firstWord);
+   Word *lastWord = words->getRef (line->lastWord);
+
+   for (int i = line->firstWord; i < line->lastWord; i++)
+      words->getRef(i)->origSpace = words->getRef(i)->effSpace;
+
+   if (firstWord->content.type != core::Content::BREAK) {
+      switch (firstWord->style->textAlign) {
+      case core::style::TEXT_ALIGN_LEFT:
+      case core::style::TEXT_ALIGN_STRING:   /* handled elsewhere (in the
+                                              * future)? */
+         line->leftOffset = 0;
+         break;
+      case core::style::TEXT_ALIGN_JUSTIFY:  /* see some lines above */
+         line->leftOffset = 0;
+         if(lastWord->content.type != core::Content::BREAK &&
+            line->lastWord != words->size () - 1) {
+            PRINTF ("      justifyLine => %d vs. %d\n",
+                    lastWord->totalWidth, availWidth);
+            justifyLine (line, availWidth - lastWord->totalWidth);
+         }
+         break;
+      case core::style::TEXT_ALIGN_RIGHT:
+         line->leftOffset = availWidth - lastWord->totalWidth;
+         break;
+      case core::style::TEXT_ALIGN_CENTER:
+         line->leftOffset = (availWidth - lastWord->totalWidth) / 2;
+         break;
+      default:
+         /* compiler happiness */
+         line->leftOffset = 0;
+      }
+
+      /* For large lines (images etc), which do not fit into the viewport: */
+      if (line->leftOffset < 0)
+         line->leftOffset = 0;
+   }
+}
+
+/**
+ * Rewrap the page from the line from which this is necessary.
+ * There are basically two times we'll want to do this:
+ * either when the viewport is resized, or when the size changes on one
+ * of the child widgets.
+ */
+void Textblock::rewrap ()
+{
+   PRINTF ("[%p] REWRAP: wrapRef = %d\n", this, wrapRef);
+
+   if (wrapRef == -1)
+      /* page does not have to be rewrapped */
+      return;
+
+   /* All lines up from wrapRef will be rebuild from the word list,
+    * the line list up from this position is rebuild. */
+   lines->setSize (wrapRef);
+   nonTemporaryLines = misc::min (nonTemporaryLines, wrapRef);
+
+   int firstWord;
+   if (lines->size () > 0)
+      firstWord = lines->getLastRef()->lastWord + 1;
+   else
+      firstWord = 0;
+
+   for (int i = firstWord; i < words->size (); i++) {
+      Word *word = words->getRef (i);
+         
+      if (word->content.type == core::Content::WIDGET)
+         calcWidgetSize (word->content.widget, &word->size);
+      
+      wordWrap (i, false);
+      
+      if (word->content.type == core::Content::WIDGET) {
+         word->content.widget->parentRef = lines->size () - 1;
+      }
+   }
+
+   /* Next time, the page will not have to be rewrapped. */
+   wrapRef = -1;
+}
+
+void Textblock::showMissingLines ()
+{
+   int firstWordToWrap = lines->size () > 0 ?
+      lines->getRef(lines->size () - 1)->lastWord + 1 : 0;
+   for (int i = firstWordToWrap; i < words->size (); i++)
+      wordWrap (i, true);
+}
+
+
+void Textblock::removeTemporaryLines ()
+{
+   lines->setSize (nonTemporaryLines);
+}
+
+} // namespace dw
diff --git a/dw/types.hh b/dw/types.hh
index eac834ff..65983fad 100644
--- a/dw/types.hh
+++ b/dw/types.hh
@@ -194,16 +194,12 @@ struct Content
       REAL_CONTENT      = 0xff ^ (START | END),
       SELECTION_CONTENT = TEXT | WIDGET | BREAK
    };
-   enum BreakType {
-      BREAK_NO,
-      BREAK_OK
-   };
+
    /* Content is embedded in struct Word therefore we
     * try to be space efficient.
     */
    short type;
    bool space;
-   unsigned char breakType;
    union {
       const char *text;
       Widget *widget;
diff --git a/lout/container.hh b/lout/container.hh
index 8a9e3e0f..d2484b13 100644
--- a/lout/container.hh
+++ b/lout/container.hh
@@ -3,6 +3,8 @@
 
 #include "object.hh"
 
+namespace lout {
+
 /**
  * \brief This namespace contains a framework for container classes, which
  *    members are instances of object::Object.
@@ -15,8 +17,6 @@
  *
  * \sa container::untyped, container::typed
  */
-namespace lout {
-
 namespace container {
 
 /**
diff --git a/lout/identity.hh b/lout/identity.hh
index 6102933d..1f0b4bdf 100644
--- a/lout/identity.hh
+++ b/lout/identity.hh
@@ -5,12 +5,11 @@
 #include "container.hh"
 #include "signal.hh"
 
+namespace lout {
+
 /**
  * \brief Some stuff to identify classes of objects at run-time.
  */
-
-namespace lout {
-
 namespace identity {
 
 /**
diff --git a/lout/misc.hh b/lout/misc.hh
index 2a8584eb..05b87602 100644
--- a/lout/misc.hh
+++ b/lout/misc.hh
@@ -7,13 +7,13 @@
 #include <string.h>
 #include <assert.h>
 
+namespace lout {
+
 /**
  * \brief Miscellaneous stuff, which does not fit anywhere else.
  *
  * Actually, the other parts, beginning with ::object, depend on this.
  */
-namespace lout {
-
 namespace misc {
 
 template <class T> inline T min (T a, T b) { return a < b ? a : b; }
@@ -201,6 +201,38 @@ public:
    }
 
    /**
+    * \brief Return the reference of the first element (convenience method).
+    */
+   inline T* getFirstRef () {
+      assert (this->num > 0);
+      return this->array;
+   }
+
+   /**
+    * \brief Return the first element, explicitly.
+    */
+   inline T getFirst () {
+      assert (this->num > 0);
+      return this->array[0];
+   }
+
+   /**
+    * \brief Return the reference of the last element (convenience method).
+    */
+   inline T* getLastRef () {
+      assert (this->num > 0);
+      return this->array + this->num - 1;
+   }
+
+   /**
+    * \brief Return the last element, explicitly.
+    */
+   inline T getLast () {
+      assert (this->num > 0);
+      return this->array[this->num - 1];
+   }
+
+   /**
     * \brief Store an object in the vector.
     *
     * Unlike in container::untyped::Vector and container::typed::Vector,
diff --git a/lout/object.hh b/lout/object.hh
index 789542fe..9df69987 100644
--- a/lout/object.hh
+++ b/lout/object.hh
@@ -6,12 +6,12 @@
 
 #include "misc.hh"
 
+namespace lout {
+
 /**
  * \brief Here, some common classes (or interfaces) are defined, to standardize
  *    the access to other classes.
  */
-namespace lout {
-
 namespace object {
 
 /**
diff --git a/lout/signal.hh b/lout/signal.hh
index 6b332203..117779d6 100644
--- a/lout/signal.hh
+++ b/lout/signal.hh
@@ -4,6 +4,8 @@
 #include "object.hh"
 #include "container.hh"
 
+namespace lout {
+
 /**
  * \brief This namespace provides base classes to define signals.
  *
@@ -174,8 +176,6 @@
  * After this, &\em barReceiver can be connected to all instances of
  * BarEmitter, also multiple times.
  */
-namespace lout {
-
 namespace signal {
 
 class Receiver;
diff --git a/test/KHM1.html b/test/KHM1.html
new file mode 100644
index 00000000..b3924409
--- /dev/null
+++ b/test/KHM1.html
@@ -0,0 +1,56 @@
+<div style="text-align: justify">
+<p>In den al&shy;ten Zei&shy;ten, wo das Wün&shy;schen noch
+ge&shy;hol&shy;fen hat, leb&shy;te ein Kö&shy;nig, des&shy;sen
+Töch&shy;ter wa&shy;ren al&shy;le schön, aber die jüng&shy;ste war so
+schön, daß die Son&shy;ne sel&shy;ber, die doch so vie&shy;les
+ge&shy;se&shy;hen hat, sich ver&shy;wun&shy;der&shy;te so oft sie ihr
+ins Ge&shy;sicht schien. Na&shy;he bei dem Schlos&shy;se des
+Kö&shy;nigs lag ein gro&shy;ßer dunk&shy;ler Wald, und in dem
+Wal&shy;de un&shy;ter ei&shy;ner al&shy;ten Lin&shy;de war ein
+Brun&shy;nen: wenn nun der Tag recht heiß war, so ging das
+Kö&shy;nigs&shy;kind hin&shy;aus in den Wald und setz&shy;te sich an
+den Rand des küh&shy;len Brun&shy;nens: und wenn sie
+Lan&shy;ge&shy;wei&shy;le hat&shy;te, so nahm sie eine
+gol&shy;de&shy;ne Ku&shy;gel, warf sie in die Hö&shy;he und fieng sie
+wie&shy;der; und das war ihr liebs&shy;tes Spiel&shy;werk.</p>
+<p>Nun trug es sich ein&shy;mal zu, daß die gol&shy;de&shy;ne
+Ku&shy;gel der Kön&shy;igs&shy;toch&shy;ter nicht in ihr Händ&shy;chen
+fiel, das sie in die Hö&shy;he ge&shy;hal&shy;ten hat&shy;te,
+son&shy;dern vor&shy;bei auf die Er&shy;de schlug und
+ge&shy;ra&shy;de&shy;zu ins Was&shy;ser hin&shy;ein roll&shy;te. Die
+Kö&shy;nigs&shy;toch&shy;ter folg&shy;te ihr mit den Aug&shy;en nach,
+aber die Ku&shy;gel ver&shy;schwand, und der Brun&shy;nen war tief, so
+tief daß man kei&shy;nen Grund sah. Da fieng sie an zu wei&shy;nen und
+wein&shy;te im&shy;mer lau&shy;ter und konn&shy;te sich gar nicht
+trös&shy;ten. Und wie sie so klag&shy;te, rief ihr je&shy;mand zu „was
+hast du vor, Kö&shy;nigs&shy;toch&shy;ter, du schreist ja daß sich ein
+Stein er&shy;bar&shy;men möchte.“ Sie sah sich um, wo&shy;her die
+Stim&shy;me kä&shy;me, da er&shy;blick&shy;te sie einen Frosch, der
+sei&shy;nen di&shy;cken häß&shy;li&shy;chen Kopf aus dem Was&shy;ser
+streck&shy;te. „Ach, du bists, al&shy;ter
+Was&shy;ser&shy;pat&shy;scher,“ sag&shy;te sie, „ich wei&shy;ne über
+mei&shy;ne gol&shy;de&shy;ne Ku&shy;gel, die mir in den Brun&shy;nen
+hin&shy;ab ge&shy;fal&shy;len ist.“ „Sei still und wei&shy;ne nicht,“
+ant&shy;wor&shy;te&shy;te der Frosch, „ich kann wohl Rath
+schaf&shy;fen, aber was gibst du mir, wenn ich dein Spiel&shy;werk
+wie&shy;der her&shy;auf&shy;ho&shy;le?“ „Was du ha&shy;ben willst,
+lie&shy;ber Frosch,“ sag&shy;te sie, „mei&shy;ne Klei&shy;der,
+mei&shy;ne Per&shy;len und Edel&shy;stei&shy;ne, auch noch die
+gol&shy;de&shy;ne Kro&shy;ne, die ich tra&shy;ge.“ Der Frosch
+ant&shy;wor&shy;te&shy;te „dei&shy;ne Klei&shy;der, dei&shy;ne
+Per&shy;len und Edel&shy;stei&shy;ne, und dei&shy;ne gol&shy;de&shy;ne
+Kro&shy;ne, die mag ich nicht: aber wenn du mich lieb ha&shy;ben
+willst, und ich soll dein Ge&shy;sel&shy;le und
+Spiel&shy;ka&shy;me&shy;rad sein, an dei&shy;nem Tisch&shy;lein
+ne&shy;ben dir si&shy;tzen, von dei&shy;nem gol&shy;de&shy;nen
+Tel&shy;ler&shy;lein es&shy;sen, aus dei&shy;nem Be&shy;cher&shy;lein
+trin&shy;ken, in dei&shy;nem Bett&shy;lein schla&shy;fen: wenn du mir
+das ver&shy;sprichst, so will ich hin&shy;un&shy;ter stei&shy;gen und
+dir die gol&shy;de&shy;ne Ku&shy;gel wie&shy;der her&shy;auf
+ho&shy;len.“ „Ach ja,“ sag&shy;te sie, „ich ver&shy;spre&shy;che dir
+alles, was du willst, wenn du mir nur die Ku&shy;gel wie&shy;der
+bringst.“ Sie dach&shy;te aber „was der ein&shy;fäl&shy;ti&shy;ge
+Frosch schwätzt, der sitzt im Was&shy;ser bei sei&shy;nes
+Glei&shy;chen und quackt, und kann kei&shy;nes Men&shy;schen
+Ge&shy;sel&shy;le sein.“</p>
+</div>
diff --git a/test/KHM1b.html b/test/KHM1b.html
new file mode 100644
index 00000000..adefc1ef
--- /dev/null
+++ b/test/KHM1b.html
@@ -0,0 +1,14 @@
+<p style="text-align: justify">In den al&shy;ten Zei&shy;ten, wo das
+Wün&shy;schen noch ge&shy;hol&shy;fen hat, leb&shy;te ein Kö&shy;nig,
+des&shy;sen Töch&shy;ter wa&shy;ren al&shy;le schön, aber die
+jüng&shy;ste war so schön, daß die Son&shy;ne sel&shy;ber, die doch so
+vie&shy;les ge&shy;se&shy;hen hat, sich ver&shy;wun&shy;der&shy;te so
+oft sie ihr ins Ge&shy;sicht schien. Na&shy;he bei dem Schlos&shy;se
+des Kö&shy;nigs lag ein gro&shy;ßer dunk&shy;ler Wald, und in dem
+Wal&shy;de un&shy;ter ei&shy;ner al&shy;ten Lin&shy;de war ein
+Brun&shy;nen: wenn nun der Tag recht heiß war, so ging das
+Kö&shy;nigs&shy;kind hin&shy;aus in den Wald und setz&shy;te sich an
+den Rand des küh&shy;len Brun&shy;nens: und wenn sie
+Lan&shy;ge&shy;wei&shy;le hat&shy;te, so nahm sie eine
+gol&shy;de&shy;ne Ku&shy;gel, warf sie in die Hö&shy;he und fieng sie
+wie&shy;der; und das war ihr liebs&shy;tes Spiel&shy;werk.</p>
diff --git a/test/KHM1c.html b/test/KHM1c.html
new file mode 100644
index 00000000..3f3271fc
--- /dev/null
+++ b/test/KHM1c.html
@@ -0,0 +1,10 @@
+<p style="text-align: justify">In den alten Zeiten, wo das Wünschen
+noch geholfen hat, lebte ein König, dessen Töchter waren alle schön,
+aber die jüngste war so schön, daß die Sonne selber, die doch so
+vieles gesehen hat, sich verwunderte so oft sie ihr ins Gesicht
+schien. Nahe bei dem Schlosse des Königs lag ein großer dunkler Wald,
+und in dem Walde unter einer alten Linde war ein Brunnen: wenn nun der
+Tag recht heiß war, so ging das Königskind hinaus in den Wald und
+setzte sich an den Rand des kühlen Brunnens: und wenn sie Langeweile
+hatte, so nahm sie eine goldene Kugel, warf sie in die Höhe und fieng
+sie wieder; und das war ihr liebstes Spielwerk.</p>
diff --git a/test/Makefile.am b/test/Makefile.am
index a0a23c6a..daa2cef5 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -21,7 +21,8 @@ noinst_PROGRAMS = \
 	dw-ui-test \
 	fltk-browser \
 	shapes \
-	cookies
+	cookies \
+	liang
 
 dw_anchors_test_SOURCES = dw_anchors_test.cc
 dw_anchors_test_LDADD = \
@@ -159,3 +160,7 @@ cookies_SOURCES = cookies.c
 cookies_LDADD = \
 	$(top_builddir)/dpip/libDpip.a \
 	$(top_builddir)/dlib/libDlib.a
+
+liang_SOURCES = liang.cc
+
+liang_LDADD = $(top_builddir)/lout/liblout.a
diff --git a/test/liang.cc b/test/liang.cc
new file mode 100644
index 00000000..3c402e6f
--- /dev/null
+++ b/test/liang.cc
@@ -0,0 +1,184 @@
+#include "../lout/misc.hh"
+#include "../lout/object.hh"
+#include "../lout/container.hh"
+#include <stdio.h>
+#include <string.h>
+
+#define LEN 1000
+
+/*
+ * This is a direct translation of the Python implementation by Ned
+ * Batchelder.
+ */
+
+class Hyphenator
+{
+private:
+   lout::container::typed::HashTable <lout::object::Integer,
+                                      lout::container::typed::Collection
+                                      <lout::object::Integer> > *tree;
+   void insertPattern (char *s);
+
+public:
+   Hyphenator (const char *filename);
+   
+   lout::container::typed::Vector <lout::object::String>
+   *hyphenateWord(const char *word);
+};
+
+using namespace lout::object;
+using namespace lout::container::typed;
+
+Hyphenator::Hyphenator (const char *filename)
+{
+   tree = new HashTable <Integer, Collection <Integer> > (true, true);
+
+   FILE *file = fopen (filename, "r");
+   while (!feof (file)) {
+      char buf[LEN + 1];
+      char *s = fgets (buf, LEN, file);
+      if (s) {
+         int l = strlen (s);
+         if (s[l - 1] == '\n')
+            s[l - 1] = 0;
+         insertPattern (s);
+      }
+   }
+   fclose (file);
+}
+
+void Hyphenator::insertPattern (char *s)
+{
+   // Convert the a pattern like 'a1bc3d4' into a string of chars 'abcd'
+   // and a list of points [ 0, 1, 0, 3, 4 ].
+   int l = strlen (s);
+   char chars [l + 1];
+   Vector <Integer> *points = new Vector <Integer> (1, true);
+
+   // TODO numbers consisting of multiple digits?
+   // TODO Encoding: This implementation works exactly like the Python
+   // implementation, based on UTF-8. Does this always work?
+   int numChars = 0;
+   for (int i = 0; s[i]; i++)
+      if (s[i] >= '0' && s[i] <= '9')
+         points->put (new Integer (s[i] - '0'), numChars);
+      else
+         chars[numChars++] = s[i];
+   chars[numChars] = 0;
+
+   for (int i = 0; i < numChars + 1; i++) {
+      Integer *val = points->get (i);
+      if (val == NULL)
+         points->put (new Integer (0), i);
+   }
+
+   // Insert the pattern into the tree.  Each character finds a dict
+   // another level down in the tree, and leaf nodes have the list of
+   // points.
+
+   HashTable <Integer, Collection <Integer> > *t = tree;
+   for (int i = 0; chars[i]; i++) {
+      Integer c (chars[i]);
+      if (!t->contains(&c))
+         t->put (new Integer (chars[i]),
+                 new HashTable <Integer, Collection <Integer> > (true, true));
+      t = (HashTable <Integer, Collection <Integer> >*) t->get (&c);
+   }
+
+   t->put (new Integer (0), points);
+}
+
+/**
+ * Given a word, returns a list of pieces, broken at the possible
+ * hyphenation points.
+ */
+Vector <String> *Hyphenator::hyphenateWord(const char *word)
+{
+   // Short words aren't hyphenated.
+   if (strlen (word) <= 4) // TODO UTF-8
+      return NULL; // TODO
+
+   // If the word is an exception, get the stored points.
+   // TODO
+
+   char work[strlen (word) + 3];
+   strcpy (work, ".");
+   strcat (work, word); // TODO tolower
+   strcat (work, ".");
+   
+   int l = strlen (work);
+   Vector <Integer> points (l + 1, true);
+   for (int i = 0; i < l + 1; i++)
+      points.put (new Integer (0), i);
+
+   Integer null (0);
+
+   for (int i = 0; i < l; i++) {
+      HashTable <Integer, Collection <Integer> > *t = tree;
+      for (int j = i; j < l; j++) {
+         Integer c (work[j]);
+         if (t->contains (&c)) {
+            t = (HashTable <Integer, Collection <Integer> >*) t->get (&c);
+            if (t->contains (&null)) {
+               Vector <Integer> *p = (Vector <Integer>*) t->get (&null);
+
+               for (int k = 0; k < p->size (); k++) {
+                  Integer *v1 = points.get (i + k);
+                  Integer *v2 = p->get (k);
+                  // TODO Not very efficient, especially here: too much
+                  // calls of "new"
+                  points.put(new Integer (lout::misc::max (v1->getValue (),
+                                                           v2->getValue ())),
+                             i + k);
+               }
+            }
+         } else
+            break;
+      }
+   }  
+
+   // No hyphens in the first two chars or the last two.
+   points.put (new Integer (0), 1);
+   points.put (new Integer (0), 2);
+   points.put (new Integer (0), points.size () - 2);
+   points.put (new Integer (0), points.size () - 3);
+ 
+   // Examine the points to build the pieces list.
+   Vector <String> *pieces = new Vector <String> (1, true);
+   char temp[strlen (word) + 1], *ptemp = temp;
+
+   int n = lout::misc::min ((int)strlen (word), points.size () - 2);
+   for (int i = 0; i < n; i++) {
+      char c = word[i];
+      int p = points.get(i + 2)->getValue ();
+      
+      *(ptemp++) = c;
+      if (p % 2) {
+         *ptemp = 0;
+         printf ("'%s'\n", temp);
+         ptemp = temp;
+      }
+   }
+
+   *ptemp = 0;
+   printf ("'%s'\n", temp);
+
+   return pieces;
+}
+
+int main (int argc, char *argv[])
+{
+   Hyphenator h ("test/hyph-de-1996.pat");
+   h.hyphenateWord ("jahrhundertroman");
+   puts ("---");
+   h.hyphenateWord ("währenddessen");
+   puts ("---");
+   h.hyphenateWord ("ückerdorf");
+   puts ("---");
+   h.hyphenateWord ("über");
+   puts ("---");
+   h.hyphenateWord ("aber");
+   puts ("---");
+
+   return 0;
+}