merge

1 files changed, 678 insertions, 0 deletions

diff --git a/src/styleengine.cc b/src/styleengine.cc
new file mode 100644
index 00000000..906f47ee
--- /dev/null
+++ b/src/styleengine.cc
@@ -0,0 +1,678 @@
+/*
+ * File: styleengine.cc
+ *
+ * Copyright 2008-2009 Johannes Hofmann <Johannes.Hofmann@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "../dlib/dlib.h"
+#include "msg.h"
+#include "prefs.h"
+#include "html_common.hh"
+#include "styleengine.hh"
+
+using namespace dw::core::style;
+
+StyleEngine::StyleEngine (dw::core::Layout *layout) {
+   StyleAttrs style_attrs;
+   FontAttrs font_attrs;
+
+   doctree = new Doctree ();
+   stack = new lout::misc::SimpleVector <Node> (1);
+   cssContext = new CssContext ();
+   this->layout = layout;
+   importDepth = 0;
+
+   stack->increase ();
+   Node *n = stack->getRef (stack->size () - 1);
+
+   /* Create a dummy font, attribute, and tag for the bottom of the stack. */
+   font_attrs.name = prefs.font_sans_serif;
+   font_attrs.size = (int) (14 * prefs.font_factor + 0.5);
+   if (font_attrs.size < prefs.font_min_size)
+      font_attrs.size = prefs.font_min_size;
+   if (font_attrs.size > prefs.font_max_size)
+      font_attrs.size = prefs.font_max_size;
+   font_attrs.weight = 400;
+   font_attrs.style = FONT_STYLE_NORMAL;
+   font_attrs.letterSpacing = 0;
+
+   style_attrs.initValues ();
+   style_attrs.font = Font::create (layout, &font_attrs);
+   style_attrs.color = Color::create (layout, 0);
+   style_attrs.backgroundColor = Color::create (layout, 0xffffff);
+
+   n->style = Style::create (layout, &style_attrs);
+   n->wordStyle = NULL;
+   n->styleAttribute = NULL;
+   n->inheritBackgroundColor = false;
+}
+
+StyleEngine::~StyleEngine () {
+   while (doctree->top ())
+      endElement (doctree->top ()->element);
+   delete stack;
+   delete doctree;
+   delete cssContext;
+}
+
+/**
+ * \brief tell the styleEngine that a new html element has started.
+ */
+void StyleEngine::startElement (int element) {
+   if (stack->getRef (stack->size () - 1)->style == NULL)
+      style0 ();
+
+   stack->increase ();
+   Node *n = stack->getRef (stack->size () - 1);
+   n->style = NULL;
+   n->wordStyle = NULL;
+   n->styleAttribute = NULL;
+   n->inheritBackgroundColor = false;
+
+   DoctreeNode *dn = doctree->push ();
+   dn->element = element;
+}
+
+void StyleEngine::startElement (const char *tagname) {
+   startElement (a_Html_tag_index (tagname));
+}
+
+void StyleEngine::setId (const char *id) {
+   DoctreeNode *dn =  doctree->top ();
+   assert (dn->id == NULL);
+   dn->id = dStrdup (id);
+};
+
+/**
+ * \brief split a string at sep chars and return a SimpleVector of strings
+ */
+static lout::misc::SimpleVector<char *> *splitStr (const char *str, char sep) {
+   const char *p1 = NULL;
+   lout::misc::SimpleVector<char *> *list =
+      new lout::misc::SimpleVector<char *> (1);
+
+   for (;; str++) {
+      if (*str != '\0' && *str != sep) {
+         if (!p1)
+            p1 = str;
+      } else if (p1) {
+         list->increase ();
+         list->set (list->size () - 1, dStrndup (p1, str - p1));
+         p1 = NULL;
+      }
+
+      if (*str == '\0')
+         break;
+   }
+
+   return list;
+}
+
+void StyleEngine::setClass (const char *klass) {
+   DoctreeNode *dn = doctree->top ();
+   assert (dn->klass == NULL);
+   dn->klass = splitStr (klass, ' ');
+};
+
+void StyleEngine::setStyle (const char *style) {
+   Node *n = stack->getRef (stack->size () - 1);
+   assert (n->styleAttribute == NULL);
+   n->styleAttribute = dStrdup (style);
+};
+
+/**
+ * \brief set properties that were definded using (mostly deprecated) HTML
+ *    attributes (e.g. bgColor).
+ */
+void StyleEngine::setNonCssHints (CssPropertyList *nonCssHints) {
+   if (stack->getRef (stack->size () - 1)->style)
+      stack->getRef (stack->size () - 1)->style->unref ();
+   style0 (nonCssHints); // evaluate now, so caller can free nonCssHints
+}
+
+/**
+ * \brief Use of the background color of the parent style as default.
+ *   This is only used in table code to allow for colors specified for
+ *   table rows as table rows are currently no widgets and therefore
+ *   don't draw any background.
+ */
+void StyleEngine::inheritBackgroundColor () {
+   stack->getRef (stack->size () - 1)->inheritBackgroundColor = true;
+}
+
+/**
+ * \brief set the CSS pseudo class :link.
+ */
+void StyleEngine::setPseudoLink () {
+   DoctreeNode *dn = doctree->top ();
+   dn->pseudo = "link";
+}
+
+/**
+ * \brief set the CSS pseudo class :visited.
+ */
+void StyleEngine::setPseudoVisited () {
+   DoctreeNode *dn = doctree->top ();
+   dn->pseudo = "visited";
+}
+
+/**
+ * \brief tell the styleEngine that a html element has ended.
+ */
+void StyleEngine::endElement (int element) {
+   assert (stack->size () > 0);
+   assert (element == doctree->top ()->element);
+
+   Node *n = stack->getRef (stack->size () - 1);
+
+   if (n->style)
+      n->style->unref ();
+   if (n->wordStyle)
+      n->wordStyle->unref ();
+   if (n->styleAttribute)
+      dFree ((void*) n->styleAttribute);
+
+   doctree->pop ();
+   stack->setSize (stack->size () - 1);
+}
+
+/**
+ * \brief Make changes to StyleAttrs attrs according to CssPropertyList props.
+ */
+void StyleEngine::apply (StyleAttrs *attrs, CssPropertyList *props) {
+   FontAttrs fontAttrs = *attrs->font;
+   Font *parentFont = stack->get (stack->size () - 2).style->font;
+   char *c, *fontName;
+   int lineHeight;
+
+   /* Determine font first so it can be used to resolve relative lenths. */
+   for (int i = 0; i < props->size (); i++) {
+      CssProperty *p = props->getRef (i);
+
+      switch (p->name) {
+         case CSS_PROPERTY_FONT_FAMILY:
+            // Check font names in comma separated list.
+            // Note, that p->value.strVal is modified, so that in future calls
+            // the matching font name can be used directly.
+            fontName = NULL;
+            while (p->value.strVal) {
+               if ((c = strchr(p->value.strVal, ',')))
+                  *c = '\0';
+               dStrstrip(p->value.strVal);
+
+               if (strcmp (p->value.strVal, "serif") == 0)
+                  fontName = prefs.font_serif;
+               else if (strcmp (p->value.strVal, "sans-serif") == 0)
+                  fontName = prefs.font_sans_serif;
+               else if (strcmp (p->value.strVal, "cursive") == 0)
+                  fontName = prefs.font_cursive;
+               else if (strcmp (p->value.strVal, "fantasy") == 0)
+                  fontName = prefs.font_fantasy;
+               else if (strcmp (p->value.strVal, "monospace") == 0)
+                  fontName = prefs.font_monospace;
+               else if (Font::exists(layout, p->value.strVal))
+                  fontName = p->value.strVal;
+
+               if (fontName) {   // font found
+                  fontAttrs.name = fontName;
+                  break;
+               } else if (c) {   // try next from list
+                  memmove(p->value.strVal, c + 1, strlen(c + 1) + 1);
+               } else {          // no font found
+                  break;
+               }
+            }
+
+            break;
+         case CSS_PROPERTY_FONT_SIZE:
+            if (p->type == CSS_TYPE_ENUM) {
+               switch (p->value.intVal) {
+                  case CSS_FONT_SIZE_XX_SMALL:
+                     fontAttrs.size = (int) (11.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_X_SMALL:
+                     fontAttrs.size = (int) (12.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_SMALL:
+                     fontAttrs.size = (int) (13.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_MEDIUM:
+                     fontAttrs.size = (int) (14.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_LARGE:
+                     fontAttrs.size = (int) (15.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_X_LARGE:
+                     fontAttrs.size = (int) (16.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_XX_LARGE:
+                     fontAttrs.size = (int) (17.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_SMALLER:
+                     fontAttrs.size -= (int) (1.0 * prefs.font_factor + 0.5);
+                     break;
+                  case CSS_FONT_SIZE_LARGER:
+                     fontAttrs.size += (int) (1.0 * prefs.font_factor + 0.5);
+                     break;
+                  default:
+                     assert(false); // invalid font-size enum
+               }
+            } else {
+               computeValue (&fontAttrs.size, p->value.intVal, parentFont,
+                  parentFont->size);
+            }
+
+            if (fontAttrs.size < prefs.font_min_size)
+               fontAttrs.size = prefs.font_min_size;
+            if (fontAttrs.size > prefs.font_max_size)
+               fontAttrs.size = prefs.font_max_size;
+
+            break;
+         case CSS_PROPERTY_FONT_STYLE:
+            fontAttrs.style = (FontStyle) p->value.intVal;
+            break;
+         case CSS_PROPERTY_FONT_WEIGHT:
+
+            if (p->type == CSS_TYPE_ENUM) {
+               switch (p->value.intVal) {
+                  case CSS_FONT_WEIGHT_BOLD:
+                     fontAttrs.weight = 700;
+                     break;
+                  case CSS_FONT_WEIGHT_BOLDER:
+                     fontAttrs.weight += 300;
+                     break;
+                  case CSS_FONT_WEIGHT_LIGHT:
+                     fontAttrs.weight = 100;
+                     break;
+                  case CSS_FONT_WEIGHT_LIGHTER:
+                     fontAttrs.weight -= 300;
+                     break;
+                  case CSS_FONT_WEIGHT_NORMAL:
+                     fontAttrs.weight = 400;
+                     break;
+                  default:
+                     assert(false); // invalid font weight value
+                     break;
+               }
+            } else {
+               fontAttrs.weight = p->value.intVal;
+            }
+
+            if (fontAttrs.weight < 100)
+               fontAttrs.weight = 100;
+            if (fontAttrs.weight > 900)
+               fontAttrs.weight = 900;
+
+            break;
+         case CSS_PROPERTY_LETTER_SPACING:
+            if (p->type == CSS_TYPE_ENUM) {
+               if (p->value.intVal == CSS_LETTER_SPACING_NORMAL) {
+                  fontAttrs.letterSpacing = 0;
+               }
+            } else {
+               computeValue (&fontAttrs.letterSpacing, p->value.intVal,
+                  parentFont, parentFont->size);
+            }
+
+            /* Limit letterSpacing to reasonable values to avoid overflows e.g,
+             * when measuring word width.
+             */
+            if (fontAttrs.letterSpacing > 1000)
+               fontAttrs.letterSpacing = 1000;
+            else if (fontAttrs.letterSpacing < -1000)
+               fontAttrs.letterSpacing = -1000;
+            break;
+         default:
+            break;
+      }
+   }
+
+   attrs->font = Font::create (layout, &fontAttrs);
+
+   for (int i = 0; i < props->size (); i++) {
+      CssProperty *p = props->getRef (i);
+
+      switch (p->name) {
+         /* \todo missing cases */
+         case CSS_PROPERTY_BACKGROUND_COLOR:
+            if (prefs.allow_white_bg || p->value.intVal != 0xffffff)
+               attrs->backgroundColor = Color::create(layout, p->value.intVal);
+            else
+               //attrs->backgroundColor = Color::create(layout, 0xdcd1ba);
+               attrs->backgroundColor = Color::create(layout, 0xe0e0a3);
+            break;
+         case CSS_PROPERTY_BORDER_TOP_COLOR:
+            attrs->borderColor.top =
+              Color::create (layout, p->value.intVal);
+            break;
+         case CSS_PROPERTY_BORDER_BOTTOM_COLOR:
+            attrs->borderColor.bottom =
+              Color::create (layout, p->value.intVal);
+            break;
+         case CSS_PROPERTY_BORDER_LEFT_COLOR:
+            attrs->borderColor.left =
+              Color::create (layout, p->value.intVal);
+            break;
+         case CSS_PROPERTY_BORDER_RIGHT_COLOR:
+            attrs->borderColor.right =
+              Color::create (layout, p->value.intVal);
+            break;
+         case CSS_PROPERTY_BORDER_BOTTOM_STYLE:
+            attrs->borderStyle.bottom = (BorderStyle) p->value.intVal;
+            break;
+         case CSS_PROPERTY_BORDER_LEFT_STYLE:
+            attrs->borderStyle.left = (BorderStyle) p->value.intVal;
+            break;
+         case CSS_PROPERTY_BORDER_RIGHT_STYLE:
+            attrs->borderStyle.right = (BorderStyle) p->value.intVal;
+            break;
+         case CSS_PROPERTY_BORDER_TOP_STYLE:
+            attrs->borderStyle.top = (BorderStyle) p->value.intVal;
+            break;
+         case CSS_PROPERTY_BORDER_BOTTOM_WIDTH:
+            computeBorderWidth (&attrs->borderWidth.bottom, p, attrs->font);
+            break;
+         case CSS_PROPERTY_BORDER_LEFT_WIDTH:
+            computeBorderWidth (&attrs->borderWidth.left, p, attrs->font);
+            break;
+         case CSS_PROPERTY_BORDER_RIGHT_WIDTH:
+            computeBorderWidth (&attrs->borderWidth.right, p, attrs->font);
+            break;
+         case CSS_PROPERTY_BORDER_TOP_WIDTH:
+            computeBorderWidth (&attrs->borderWidth.top, p, attrs->font);
+            break;
+         case CSS_PROPERTY_BORDER_SPACING:
+            computeValue (&attrs->hBorderSpacing, p->value.intVal,attrs->font);
+            computeValue (&attrs->vBorderSpacing, p->value.intVal,attrs->font);
+            break;
+         case CSS_PROPERTY_COLOR:
+            attrs->color = Color::create (layout, p->value.intVal);
+            break;
+         case CSS_PROPERTY_CURSOR:
+            attrs->cursor = (Cursor) p->value.intVal;
+            break;
+         case CSS_PROPERTY_DISPLAY:
+            attrs->display = (DisplayType) p->value.intVal;
+            break;
+         case CSS_PROPERTY_LINE_HEIGHT:
+            if (p->type == CSS_TYPE_ENUM) { //only valid enum value is "normal"
+               attrs->lineHeight = dw::core::style::LENGTH_AUTO;
+            } else if (p->type == CSS_TYPE_LENGTH_PERCENTAGE_NUMBER) {
+               if (CSS_LENGTH_TYPE (p->value.intVal) == CSS_LENGTH_TYPE_NONE) {
+                  attrs->lineHeight =
+                     createPerLength(CSS_LENGTH_VALUE(p->value.intVal));
+               } else {
+                  computeValue (&lineHeight, p->value.intVal, attrs->font,
+                                attrs->font->size);
+                  attrs->lineHeight = createAbsLength(lineHeight);
+               }
+            }
+            break;
+         case CSS_PROPERTY_LIST_STYLE_POSITION:
+            attrs->listStylePosition = (ListStylePosition) p->value.intVal;
+            break;
+         case CSS_PROPERTY_LIST_STYLE_TYPE:
+            attrs->listStyleType = (ListStyleType) p->value.intVal;
+            break;
+         case CSS_PROPERTY_MARGIN_BOTTOM:
+            computeValue (&attrs->margin.bottom, p->value.intVal, attrs->font);
+            if (attrs->margin.bottom < 0) // \todo fix negative margins in dw/*
+               attrs->margin.bottom = 0;
+            break;
+         case CSS_PROPERTY_MARGIN_LEFT:
+            computeValue (&attrs->margin.left, p->value.intVal, attrs->font);
+            if (attrs->margin.left < 0) // \todo fix negative margins in dw/*
+               attrs->margin.left = 0;
+            break;
+         case CSS_PROPERTY_MARGIN_RIGHT:
+            computeValue (&attrs->margin.right, p->value.intVal, attrs->font);
+            if (attrs->margin.right < 0) // \todo fix negative margins in dw/*
+               attrs->margin.right = 0;
+            break;
+         case CSS_PROPERTY_MARGIN_TOP:
+            computeValue (&attrs->margin.top, p->value.intVal, attrs->font);
+            if (attrs->margin.top < 0) // \todo fix negative margins in dw/*
+               attrs->margin.top = 0;
+            break;
+         case CSS_PROPERTY_PADDING_TOP:
+            computeValue (&attrs->padding.top, p->value.intVal, attrs->font);
+            break;
+         case CSS_PROPERTY_PADDING_BOTTOM:
+            computeValue (&attrs->padding.bottom, p->value.intVal,attrs->font);
+            break;
+         case CSS_PROPERTY_PADDING_LEFT:
+            computeValue (&attrs->padding.left, p->value.intVal, attrs->font);
+            break;
+         case CSS_PROPERTY_PADDING_RIGHT:
+            computeValue (&attrs->padding.right, p->value.intVal, attrs->font);
+            break;
+         case CSS_PROPERTY_TEXT_ALIGN:
+            attrs->textAlign = (TextAlignType) p->value.intVal;
+            break;
+         case CSS_PROPERTY_TEXT_DECORATION:
+            attrs->textDecoration |= p->value.intVal;
+            break;
+         case CSS_PROPERTY_VERTICAL_ALIGN:
+            attrs->valign = (VAlignType) p->value.intVal;
+            break;
+         case CSS_PROPERTY_WHITE_SPACE:
+            attrs->whiteSpace = (WhiteSpace) p->value.intVal;
+            break;
+         case CSS_PROPERTY_WIDTH:
+            computeLength (&attrs->width, p->value.intVal, attrs->font);
+            break;
+         case CSS_PROPERTY_HEIGHT:
+            computeLength (&attrs->height, p->value.intVal, attrs->font);
+            break;
+         case CSS_PROPERTY_WORD_SPACING:
+            if (p->type == CSS_TYPE_ENUM) {
+               if (p->value.intVal == CSS_WORD_SPACING_NORMAL) {
+                  attrs->wordSpacing = 0;
+               }
+            } else {
+               computeValue(&attrs->wordSpacing, p->value.intVal, attrs->font);
+            }
+
+            /* Limit to reasonable values to avoid overflows */
+            if (attrs->wordSpacing > 1000)
+               attrs->wordSpacing = 1000;
+            else if (attrs->wordSpacing < -1000)
+               attrs->wordSpacing = -1000;
+            break;
+         case PROPERTY_X_LINK:
+            attrs->x_link = p->value.intVal;
+            break;
+         case PROPERTY_X_IMG:
+            attrs->x_img = p->value.intVal;
+            break;
+         case PROPERTY_X_TOOLTIP:
+            attrs->x_tooltip = Tooltip::create(layout, p->value.strVal);
+            break;
+         default:
+            break;
+      }
+   }
+
+   /* make sure border colors are set */
+   if (attrs->borderColor.top == NULL)
+      attrs->borderColor.top = attrs->color;
+   if (attrs->borderColor.bottom == NULL)
+      attrs->borderColor.bottom = attrs->color;
+   if (attrs->borderColor.left == NULL)
+      attrs->borderColor.left = attrs->color;
+   if (attrs->borderColor.right == NULL)
+      attrs->borderColor.right = attrs->color;
+
+}
+
+/**
+ * \brief Resolve relative lengths to absolute values.
+ */
+bool StyleEngine::computeValue (int *dest, CssLength value, Font *font) {
+   static float dpmm;
+
+   if (dpmm == 0.0)
+      dpmm = layout->dpiX () / 25.4; /* assume dpiX == dpiY */
+
+   switch (CSS_LENGTH_TYPE (value)) {
+      case CSS_LENGTH_TYPE_PX:
+         *dest = (int) CSS_LENGTH_VALUE (value);
+         return true;
+      case CSS_LENGTH_TYPE_MM:
+         *dest = (int) (CSS_LENGTH_VALUE (value) * dpmm + 0.5);
+        return true;
+      case CSS_LENGTH_TYPE_EM:
+         *dest = (int) (CSS_LENGTH_VALUE (value) * font->size + 0.5);
+        return true;
+      case CSS_LENGTH_TYPE_EX:
+         *dest = (int) (CSS_LENGTH_VALUE(value) * font->xHeight + 0.5);
+        return true;
+      default:
+         break;
+   }
+
+   return false;
+}
+
+bool StyleEngine::computeValue (int *dest, CssLength value, Font *font,
+                                int percentageBase) {
+   if (CSS_LENGTH_TYPE (value) == CSS_LENGTH_TYPE_PERCENTAGE) {
+      *dest = (int) (CSS_LENGTH_VALUE (value) * percentageBase + 0.5);
+      return true;
+   } else
+      return computeValue (dest, value, font);
+}
+
+bool StyleEngine::computeLength (dw::core::style::Length *dest,
+                                 CssLength value, Font *font) {
+   int v;
+
+   if (CSS_LENGTH_TYPE (value) == CSS_LENGTH_TYPE_PERCENTAGE) {
+      *dest = createPerLength (CSS_LENGTH_VALUE (value));
+      return true;
+   } else if (CSS_LENGTH_TYPE (value) == CSS_LENGTH_TYPE_AUTO) {
+      *dest = dw::core::style::LENGTH_AUTO;
+      return true;
+   } else if (computeValue (&v, value, font)) {
+      *dest = createAbsLength (v);
+      return true;
+   }
+
+   return false;
+}
+
+void StyleEngine::computeBorderWidth (int *dest, CssProperty *p,
+                                      dw::core::style::Font *font) {
+   if (p->type == CSS_TYPE_ENUM) {
+      switch (p->value.intVal) {
+         case CSS_BORDER_WIDTH_THIN:
+            *dest = 1;
+            break;
+         case CSS_BORDER_WIDTH_MEDIUM:
+            *dest = 2;
+            break;
+         case CSS_BORDER_WIDTH_THICK:
+            *dest = 3;
+            break;
+         default:
+            assert(false);
+      }
+   } else {
+      computeValue (dest, p->value.intVal, font);
+   }
+}
+
+/**
+ * \brief Similar to StyleEngine::style(), but with backgroundColor set.
+ * A normal style might have backgroundColor == NULL to indicate a transparent
+ * background. This method ensures that backgroundColor is set.
+ */
+Style * StyleEngine::backgroundStyle () {
+   StyleAttrs attrs = *style ();
+
+   for (int i = stack->size () - 1; i >= 0 && ! attrs.backgroundColor; i--)
+      attrs.backgroundColor = stack->getRef (i)->style->backgroundColor;
+
+   assert (attrs.backgroundColor);
+   return Style::create (layout, &attrs);
+}
+
+/**
+ * \brief Create a new style object based on the previously opened / closed
+ * HTML elements and the nonCssProperties that have been set.
+ * This method is private. Call style() to get a current style object.
+ */
+Style * StyleEngine::style0 (CssPropertyList *nonCssProperties) {
+   CssPropertyList props, *styleAttributeProps = NULL;
+   const char *styleAttribute =
+      stack->getRef (stack->size () - 1)->styleAttribute;
+   // get previous style from the stack
+   StyleAttrs attrs = *stack->getRef (stack->size () - 2)->style;
+
+   // Ensure that StyleEngine::style0() has not been called before for
+   // this element.
+   // Style computation is expensive so limit it as much as possible.
+   // If this assertion is hit, you need to rearrange the code that is
+   // doing styleEngine calls to call setNonCssHints() before calling
+   // style() or wordStyle() for each new element.
+   assert (stack->getRef (stack->size () - 1)->style == NULL);
+
+   // reset values that are not inherited according to CSS
+   attrs.resetValues ();
+
+   if (stack->getRef (stack->size () - 2)->inheritBackgroundColor) {
+      attrs.backgroundColor =
+         stack->getRef (stack->size () - 2)->style->backgroundColor;
+
+      attrs.valign = stack->getRef (stack->size () - 2)->style->valign;
+   }
+
+   // parse style information from style="" attribute, if it exists
+   if (styleAttribute && prefs.parse_embedded_css)
+      styleAttributeProps =
+         CssParser::parseDeclarationBlock (styleAttribute,
+                                           strlen (styleAttribute));
+
+   // merge style information
+   cssContext->apply (&props, doctree, styleAttributeProps, nonCssProperties);
+
+   // apply style
+   apply (&attrs, &props);
+
+   stack->getRef (stack->size () - 1)->style = Style::create (layout, &attrs);
+
+   if (styleAttributeProps)
+      delete styleAttributeProps;
+
+   return stack->getRef (stack->size () - 1)->style;
+}
+
+Style * StyleEngine::wordStyle0 (CssPropertyList *nonCssProperties) {
+   StyleAttrs attrs = *style ();
+   attrs.resetValues ();
+
+   if (stack->getRef (stack->size () - 1)->inheritBackgroundColor)
+      attrs.backgroundColor = style ()->backgroundColor;
+
+   attrs.valign = style ()->valign;
+
+   stack->getRef(stack->size() - 1)->wordStyle = Style::create(layout, &attrs);
+   return stack->getRef (stack->size () - 1)->wordStyle;
+}
+
+void StyleEngine::parse (DilloHtml *html, DilloUrl *url, const char *buf,
+                         int buflen, CssOrigin origin) {
+   if (importDepth > 10) { // avoid looping with recursive @import directives
+      MSG_WARN("Maximum depth of CSS @import reached--ignoring stylesheet.\n");
+      return;
+   }
+
+   importDepth++;
+   CssParser::parse (html, url, cssContext, buf, buflen, origin);
+   importDepth--;
+}