Add support for text styles.

sky/sdk/lib/framework/rendering/paragraph.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:sky' as sky;
 import 'box.dart';
 import 'object.dart';
 
 class RenderInline extends RenderObject {
   RenderInline(this.data);
   String data;
 }
 
+enum FontWeight {
+  light, // 300
+  regular, // 400
+  medium, // 500
+}
+
+int trueTypeWeightNumber(FontWeight weight) {

[jackson, 2015/06/12 01:32:50]

This global function might make sense as a getter on TextStyle (if you want to
make it public) or you could just put it in paint if you're only going to use it
once.

+  switch(weight) {
+    case FontWeight.light:
+      return 300;
+    case FontWeight.regular:
+      return 400;
+    case FontWeight.medium:
+      return 500;
+  }
+}
+
+class TextStyle {
+  final Color color;
+  final String fontSize;
+  final FontWeight fontWeight;
+
+  const TextStyle({
+    this.color,
+    this.fontSize,
+    this.fontWeight
+  });
+
+  bool operator ==(other) => other is TextStyle &&
+    color == other.color &&
+    fontSize == other.fontSize &&
+    fontWeight == other.fontWeight;
+}
+
 // Unfortunately, using full precision floating point here causes bad layouts
 // because floating point math isn't associative. If we add and subtract
 // padding, for example, we'll get different values when we estimate sizes and
 // when we actually compute layout because the operations will end up associated
 // differently. To work around this problem for now, we round fractional pixel
 // values up to the nearest whole pixel value. The right long-term fix is to do
 // layout using fixed precision arithmetic.
 double _applyFloatingPointHack(double layoutValue) {
   return layoutValue.ceilToDouble();
 }
 
 class RenderParagraph extends RenderBox {
 
   RenderParagraph({
     String text,
-    Color color
-  }) : _color = color {
+    Color color,
+    TextStyle style
+  }) : _style = style {
     _layoutRoot.rootElement = _document.createElement('p');
     this.text = text;
   }
 
   final sky.Document _document = new sky.Document();
   final sky.LayoutRoot _layoutRoot = new sky.LayoutRoot();
 
   String get text => (_layoutRoot.rootElement.firstChild as sky.Text).data;
   void set text (String value) {
     _layoutRoot.rootElement.setChild(_document.createText(value));
     markNeedsLayout();
   }
 
-  Color _color = const Color(0xFF000000);
-  Color get color => _color;
-  void set color (Color value) {
-    if (_color != value) {
-      _color = value;
-      markNeedsPaint();
+  TextStyle _style;
+  TextStyle get style => _style;
+  void set style (TextStyle value) {
+    if (_style != value) {
+      // TODO(hansmuller): decide if a new layout or paint is needed
+      markNeedsLayout();
+      _style = value;
     }
   }
 
   BoxConstraints _constraintsForCurrentLayout;
 
   sky.Element _layout(BoxConstraints constraints) {
     _layoutRoot.maxWidth = constraints.maxWidth;
     _layoutRoot.minWidth = constraints.minWidth;
     _layoutRoot.minHeight = constraints.minHeight;
     _layoutRoot.maxHeight = constraints.maxHeight;
@@ skipping 39 matching lines @@
     // Ideally we could compute the min/max intrinsic width/height with a
     // non-destructive operation. However, currently, computing these values
     // will destroy state inside the layout root. If that happens, we need to
     // get back the correct state by calling _layout again.
     //
     // TODO(abarth): Make computing the min/max intrinsic width/height a
     //               non-destructive operation.
     if (_constraintsForCurrentLayout != constraints && constraints != null)
       _layout(constraints);
 
-    if (_color != null) {
-      _layoutRoot.rootElement.style['color'] =
-          'rgba(${_color.red}, ${_color.green}, ${_color.blue}, ${_color.alpha / 255.0 })';
+    if (style != null) {
+      var cssStyle = _layoutRoot.rootElement.style;
+      if (style.color != null) {
+        Color c = style.color;
+        cssStyle['color'] =
+            'rgba(${c.red}, ${c.green}, ${c.blue}, ${c.alpha / 255.0 })';

[jackson, 2015/06/12 01:32:50]

you've got an extra space here

+      }
+      if (style.fontSize != null) {
+        cssStyle['font-size'] = style.fontSize;
+      }
+      if (style.fontWeight != null) {
+        cssStyle['font-weight'] = trueTypeWeightNumber(style.fontWeight).toString();
+      }
     }
     _layoutRoot.paint(canvas);
   }
 
   // we should probably expose a way to do precise (inter-glpyh) hit testing
 
   String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}color: ${color}\n${prefix}text: ${text}\n';
 }