pkg/csslib: formatting

lib/src/property.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /** Representations of CSS styles. */
 
 part of csslib.parser;
 
 // TODO(terry): Prune down this file we do need some of the code in this file
 //              for darker, lighter, how to represent a Font, etc but alot of
@@ skipping 11 matching lines @@
    *
    * E.g., if property is color then expression could be rgba(255,255,0) the
    *       CSS declaration would be 'color:rgba(255,255,0);'.
    *
    * then _cssExpression would return 'rgba(255,255,0)'.  See
    * <http://www.w3.org/TR/CSS21/grammar.html>
    */
   String get cssExpression;
 }
 
-
 /**
  * Base interface for Color, HSL and RGB.
  */
 abstract class ColorBase {
   /**
    * Canonical form for color #rrggbb with alpha blending (0.0 == full
    * transparency and 1.0 == fully opaque). If _argb length is 6 it's an
    * rrggbb otherwise it's aarrggbb.
    */
   String toHexArgbString();
 
   /**
    * Return argb as a value (int).
    */
   int get argbValue;
 }
 
-
 /**
  * General purpse Color class.  Represent a color as an ARGB value that can be
  * converted to and from num, hex string, hsl, hsla, rgb, rgba and SVG pre-
  * defined color constant.
  */
 class Color implements _StyleProperty, ColorBase {
   // If _argb length is 6 it's an rrggbb otherwise it's aarrggbb.
   final String _argb;
 
   // TODO(terry): Look at reducing Rgba and Hsla classes as factories for
   //              converting from Color to an Rgba or Hsla for reading only.
   //              Usefulness of creating an Rgba or Hsla is limited.
 
   /**
    * Create a color with an integer representing the rgb value of red, green,
    * and blue.  The value 0xffffff is the color white #ffffff (CSS style).
    * The [rgb] value of 0xffd700 would map to #ffd700 or the constant
    * Color.gold, where ff is red intensity, d7 is green intensity, and 00 is
    * blue intensity.
    */
-  Color(int rgb, [num alpha]) :
-    this._argb = Color._rgbToArgbString(rgb, alpha);
+  Color(int rgb, [num alpha]) : this._argb = Color._rgbToArgbString(rgb, alpha);
 
   /**
    * RGB takes three values. The [red], [green], and [blue] parameters are
    * the intensity of those components where '0' is the least and '256' is the
    * greatest.
    *
    * If [alpha] is provided, it is the level of translucency which ranges from
    * '0' (completely transparent) to '1.0' (completely opaque).  It will
    * internally be mapped to an int between '0' and '255' like the other color
    * components.
    */
-  Color.createRgba(int red, int green, int blue, [num alpha]) :
-      this._argb = Color.convertToHexString(Color._clamp(red, 0, 255),
-          Color._clamp(green, 0, 255),
-          Color._clamp(blue, 0, 255),
+  Color.createRgba(int red, int green, int blue, [num alpha])
+      : this._argb = Color.convertToHexString(Color._clamp(red, 0, 255),
+          Color._clamp(green, 0, 255), Color._clamp(blue, 0, 255),
           alpha != null ? Color._clamp(alpha, 0, 1) : alpha);
 
   /**
    * Creates a new color from a CSS color string. For more information, see
    * <https://developer.mozilla.org/en/CSS/color>.
    */
-  Color.css(String color) :
-      this._argb = Color._convertCssToArgb(color);
+  Color.css(String color) : this._argb = Color._convertCssToArgb(color);
 
   // TODO(jmesserly): I found the use of percents a bit suprising.
   /**
    * HSL takes three values.  The [hueDegree] degree on the color wheel; '0' is
    * the least and '100' is the greatest.  The value '0' or '360' is red, '120'
    * is green, '240' is blue. Numbers in between reflect different shades.
    * The [saturationPercent] percentage; where'0' is the least and '100' is the
    * greatest (100 represents full color).  The [lightnessPercent] percentage;
    * where'0' is the least and '100' is the greatest.  The value 0 is dark or
    * black, 100 is light or white and 50 is a medium lightness.
    *
    * If [alpha] is provided, it is the level of translucency which ranges from
    * '0' (completely transparent foreground) to '1.0' (completely opaque
    * foreground).
    */
   Color.createHsla(num hueDegree, num saturationPercent, num lightnessPercent,
-      [num alpha]) :
-          this._argb = new Hsla(Color._clamp(hueDegree, 0, 360) / 360,
+      [num alpha])
+      : this._argb = new Hsla(Color._clamp(hueDegree, 0, 360) / 360,
           Color._clamp(saturationPercent, 0, 100) / 100,
           Color._clamp(lightnessPercent, 0, 100) / 100,
           alpha != null ? Color._clamp(alpha, 0, 1) : alpha).toHexArgbString();
 
   /**
    * The hslaRaw takes three values.  The [hue] degree on the color wheel; '0'
    * is the least and '1' is the greatest.  The value '0' or '1' is red, the
    * ratio of 120/360 is green, and the ratio of 240/360 is blue.  Numbers in
    * between reflect different shades.  The [saturation] is a percentage; '0'
    * is the least and '1' is the greatest.  The value of '1' is equivalent to
    * 100% (full colour).  The [lightness] is a percentage; '0' is the least and
    * '1' is the greatest.  The value of '0' is dark (black), the value of '1'
    * is light (white), and the value of '.50' is a medium lightness.
    *
    * The fourth optional parameter is:
    *   [alpha]      level of translucency range of values is 0..1, zero is a
    *                completely transparent foreground and 1 is a completely
    *                opaque foreground.
    */
-  Color.hslaRaw(num hue, num saturation, num lightness, [num alpha]) :
-    this._argb = new Hsla(Color._clamp(hue, 0, 1),
-          Color._clamp(saturation, 0, 1),
-          Color._clamp(lightness, 0, 1),
+  Color.hslaRaw(num hue, num saturation, num lightness, [num alpha])
+      : this._argb = new Hsla(Color._clamp(hue, 0, 1),
+          Color._clamp(saturation, 0, 1), Color._clamp(lightness, 0, 1),
           alpha != null ? Color._clamp(alpha, 0, 1) : alpha).toHexArgbString();
 
   /**
    * Generate a real constant for pre-defined colors (no leading #).
    */
   const Color.hex(this._argb);
 
   // TODO(jmesserly): this is needed by the example so leave it exposed for now.
   String toString() => cssExpression;
 
   // TODO(terry): Regardless of how color is set (rgb, num, css or hsl) we'll
   //              always return a rgb or rgba loses fidelity when debugging in
   //              CSS if user uses hsl and would like to edit as hsl, etc.  If
   //              this is an issue we should keep the original value and not re-
   //              create the CSS from the normalized value.
   String get cssExpression {
     if (_argb.length == 6) {
-      return "#$_argb";         // RGB only, no alpha blending.
+      return "#$_argb"; // RGB only, no alpha blending.
     } else {
       num alpha = Color.hexToInt(_argb.substring(0, 2));
       String a = (alpha / 255).toStringAsPrecision(2);
       int r = Color.hexToInt(_argb.substring(2, 4));
       int g = Color.hexToInt(_argb.substring(4, 6));
       int b = Color.hexToInt(_argb.substring(6, 8));
       return "rgba($r,$g,$b,$a)";
     }
   }
 
@@ skipping 74 matching lines @@
   /**
    * Parse CSS expressions of the from #rgb, rgb(r,g,b), rgba(r,g,b,a),
    * hsl(h,s,l), hsla(h,s,l,a) and SVG colors (e.g., darkSlateblue, etc.) and
    * convert to argb.
    */
   static String _convertCssToArgb(String value) {
     // TODO(terry): Better parser/regex for converting CSS properties.
     String color = value.trim().replaceAll("\\s", "");
     if (color[0] == '#') {
       String v = color.substring(1);
-      Color.hexToInt(v);              // Valid hexadecimal, throws if not.
+      Color.hexToInt(v); // Valid hexadecimal, throws if not.
       return v;
     } else if (color.length > 0 && color[color.length - 1] == ')') {
       int type;
       if (color.indexOf("rgb(") == 0 || color.indexOf("RGB(") == 0) {
         color = color.substring(4);
         type = _rgbCss;
       } else if (color.indexOf("rgba(") == 0 || color.indexOf("RGBA(") == 0) {
         type = _rgbaCss;
         color = color.substring(5);
       } else if (color.indexOf("hsl(") == 0 || color.indexOf("HSL(") == 0) {
         type = _hslCss;
         color = color.substring(4);
       } else if (color.indexOf("hsla(") == 0 || color.indexOf("HSLA(") == 0) {
         type = _hslaCss;
         color = color.substring(5);
       } else {
         throw new UnsupportedError('CSS property not implemented');
       }
 
-      color = color.substring(0, color.length - 1);     // Strip close paren.
+      color = color.substring(0, color.length - 1); // Strip close paren.
 
       var args = <num>[];
       List<String> params = color.split(",");
       for (String param in params) {
         args.add(double.parse(param));
       }
       switch (type) {
         case _rgbCss:
           return Color.convertToHexString(args[0], args[1], args[2]);
         case _rgbaCss:
           return Color.convertToHexString(args[0], args[1], args[2], args[3]);
         case _hslCss:
           return new Hsla(args[0], args[1], args[2]).toHexArgbString();
         case _hslaCss:
-          return new Hsla(args[0], args[1], args[2],
-              args[3]).toHexArgbString();
+          return new Hsla(args[0], args[1], args[2], args[3]).toHexArgbString();
         default:
           // Type not defined UnsupportedOperationException should have thrown.
           assert(true);
           break;
       }
     }
   }
 
   static int hexToInt(String hex) => int.parse(hex, radix: 16);
 
   static String convertToHexString(int r, int g, int b, [num a]) {
     String rHex = Color._numAs2DigitHex(Color._clamp(r, 0, 255));
     String gHex = Color._numAs2DigitHex(Color._clamp(g, 0, 255));
     String bHex = Color._numAs2DigitHex(Color._clamp(b, 0, 255));
-    String aHex = (a != null) ?
-        Color._numAs2DigitHex((Color._clamp(a, 0, 1) * 255).round()) : "";
+    String aHex = (a != null)
+        ? Color._numAs2DigitHex((Color._clamp(a, 0, 1) * 255).round())
+        : "";
 
     // TODO(terry) 15.toRadixString(16) return 'F' on Dartium not f as in JS.
     //             bug: <http://code.google.com/p/dart/issues/detail?id=2670>
     return "$aHex$rHex$gHex$bHex".toLowerCase();
   }
 
   static String _numAs2DigitHex(num v) {
     // TODO(terry): v.toInt().toRadixString instead of v.toRadixString
     //              Bug <http://code.google.com/p/dart/issues/detail?id=2671>.
     String hex = v.toInt().toRadixString(16);
@@ skipping 42 matching lines @@
   /**
    * The parameter [v] is the color to change (r, g, or b) in the range '0' to
    * '255'. The parameter [delta] is a number between '-1' and '1'.  A value
    * between '-1' and '0' is darker and a value between '0' and '1' is lighter
    * ('0' imples no change).
    */
   static num _changeTintShadeColor(num v, num delta) =>
       Color._clamp(((1 - delta) * v + (delta * 255)).round(), 0, 255);
 
   // Predefined CSS colors see <http://www.w3.org/TR/css3-color/>
-  static final Color transparent = const Color.hex("00ffffff");  // Alpha 0.0
+  static final Color transparent = const Color.hex("00ffffff"); // Alpha 0.0
   static final Color aliceBlue = const Color.hex("0f08ff");
   static final Color antiqueWhite = const Color.hex("0faebd7");
   static final Color aqua = const Color.hex("00ffff");
   static final Color aquaMarine = const Color.hex("7fffd4");
   static final Color azure = const Color.hex("f0ffff");
   static final Color beige = const Color.hex("f5f5dc");
   static final Color bisque = const Color.hex("ffe4c4");
   static final Color black = const Color.hex("000000");
   static final Color blanchedAlmond = const Color.hex("ffebcd");
   static final Color blue = const Color.hex("0000ff");
@@ skipping 129 matching lines @@
   static final Color tomato = const Color.hex("ff6347");
   static final Color turquoise = const Color.hex("40e0d0");
   static final Color violet = const Color.hex("ee82ee");
   static final Color wheat = const Color.hex("f5deb3");
   static final Color white = const Color.hex("ffffff");
   static final Color whiteSmoke = const Color.hex("f5f5f5");
   static final Color yellow = const Color.hex("ffff00");
   static final Color yellowGreen = const Color.hex("9acd32");
 }
 
-
 /**
  * Rgba class for users that want to interact with a color as a RGBA value.
  */
 class Rgba implements _StyleProperty, ColorBase {
   // TODO(terry): Consider consolidating rgba to a single 32-bit int, make sure
   //              it works under JS and Dart VM.
   final int r;
   final int g;
   final int b;
   final num a;
 
-  Rgba(int red, int green, int blue, [num alpha]) :
-    this.r = Color._clamp(red, 0, 255),
-    this.g = Color._clamp(green, 0, 255),
-    this.b = Color._clamp(blue, 0, 255),
-    this.a = (alpha != null) ? Color._clamp(alpha, 0, 1) : alpha;
+  Rgba(int red, int green, int blue, [num alpha])
+      : this.r = Color._clamp(red, 0, 255),
+        this.g = Color._clamp(green, 0, 255),
+        this.b = Color._clamp(blue, 0, 255),
+        this.a = (alpha != null) ? Color._clamp(alpha, 0, 1) : alpha;
 
   factory Rgba.fromString(String hexValue) =>
-    new Color.css("#${Color._convertCssToArgb(hexValue)}").rgba;
+      new Color.css("#${Color._convertCssToArgb(hexValue)}").rgba;
 
   factory Rgba.fromColor(Color color) => color.rgba;
 
   factory Rgba.fromArgbValue(num value) {
-    return new Rgba(((value.toInt() & 0xff000000) >> 0x18),  /* a */
-      ((value.toInt() & 0xff0000) >> 0x10),                  /* r */
-      ((value.toInt() & 0xff00) >> 8),                       /* g */
-      ((value.toInt() & 0xff)));                             /* b */
+    return new Rgba(((value.toInt() & 0xff000000) >> 0x18), /* a */
+        ((value.toInt() & 0xff0000) >> 0x10), /* r */
+        ((value.toInt() & 0xff00) >> 8), /* g */
+        ((value.toInt() & 0xff))); /* b */
   }
 
   factory Rgba.fromHsla(Hsla hsla) {
     // Convert to Rgba.
     // See site <http://easyrgb.com/index.php?X=MATH> for good documentation
     // and color conversion routines.
 
     num h = hsla.hue;
     num s = hsla.saturation;
     num l = hsla.lightness;
@@ skipping 10 matching lines @@
     } else {
       num var2;
 
       if (l < 0.5) {
         var2 = l * (1 + s);
       } else {
         var2 = (l + s) - (s * l);
       }
       num var1 = 2 * l - var2;
 
-      r = (255 * Rgba._hueToRGB(var1, var2, h + (1/3))).round().toInt();
+      r = (255 * Rgba._hueToRGB(var1, var2, h + (1 / 3))).round().toInt();
       g = (255 * Rgba._hueToRGB(var1, var2, h)).round().toInt();
-      b = (255 * Rgba._hueToRGB(var1, var2, h - (1/3))).round().toInt();
+      b = (255 * Rgba._hueToRGB(var1, var2, h - (1 / 3))).round().toInt();
     }
 
     return new Rgba(r, g, b, a);
   }
 
   static num _hueToRGB(num v1, num v2, num vH) {
     if (vH < 0) {
       vH += 1;
     }
 
@@ skipping 40 matching lines @@
 
   Color get color => new Color.createRgba(r, g, b, a);
   Hsla get hsla => new Hsla.fromRgba(this);
 
   Rgba darker(num amount) => Color._createNewTintShadeFromRgba(this, -amount);
   Rgba lighter(num amount) => Color._createNewTintShadeFromRgba(this, amount);
 
   int get hashCode => toHexArgbString().hashCode;
 }
 
-
 /**
  * Hsl class support to interact with a color as a hsl with hue, saturation, and
  * lightness with optional alpha blending.  The hue is a ratio of 360 degrees
  * 360° = 1 or 0, (1° == (1/360)), saturation and lightness is a 0..1 fraction
  * (1 == 100%) and alpha is a 0..1 fraction.
  */
 class Hsla implements _StyleProperty, ColorBase {
-  final num _h;             // Value from 0..1
-  final num _s;             // Value from 0..1
-  final num _l;             // Value from 0..1
-  final num _a;             // Value from 0..1
+  final num _h; // Value from 0..1
+  final num _s; // Value from 0..1
+  final num _l; // Value from 0..1
+  final num _a; // Value from 0..1
 
   /**
    * [hue] is a 0..1 fraction of 360 degrees (360 == 0).
    * [saturation] is a 0..1 fraction (100% == 1).
    * [lightness] is a 0..1 fraction (100% == 1).
    * [alpha] is a 0..1 fraction, alpha blending between 0..1, 1 == 100% opaque.
    */
-  Hsla(num hue, num saturation, num lightness, [num alpha]) :
-    this._h = (hue == 1) ? 0 : Color._clamp(hue, 0, 1),
-    this._s = Color._clamp(saturation, 0, 1),
-    this._l = Color._clamp(lightness, 0, 1),
-    this._a = (alpha != null) ? Color._clamp(alpha, 0, 1) : alpha;
+  Hsla(num hue, num saturation, num lightness, [num alpha])
+      : this._h = (hue == 1) ? 0 : Color._clamp(hue, 0, 1),
+        this._s = Color._clamp(saturation, 0, 1),
+        this._l = Color._clamp(lightness, 0, 1),
+        this._a = (alpha != null) ? Color._clamp(alpha, 0, 1) : alpha;
 
   factory Hsla.fromString(String hexValue) {
     Rgba rgba = new Color.css("#${Color._convertCssToArgb(hexValue)}").rgba;
     return _createFromRgba(rgba.r, rgba.g, rgba.b, rgba.a);
   }
 
   factory Hsla.fromColor(Color color) {
     Rgba rgba = color.rgba;
     return _createFromRgba(rgba.r, rgba.g, rgba.b, rgba.a);
   }
 
   factory Hsla.fromArgbValue(num value) {
     num a = (value.toInt() & 0xff000000) >> 0x18;
     int r = (value.toInt() & 0xff0000) >> 0x10;
     int g = (value.toInt() & 0xff00) >> 8;
     int b = value.toInt() & 0xff;
 
     // Convert alpha to 0..1 from (0..255).
     if (a != null) {
       a = double.parse((a / 255).toStringAsPrecision(2));
     }
 
     return _createFromRgba(r, g, b, a);
   }
 
   factory Hsla.fromRgba(Rgba rgba) =>
-    _createFromRgba(rgba.r, rgba.g, rgba.b, rgba.a);
+      _createFromRgba(rgba.r, rgba.g, rgba.b, rgba.a);
 
   static Hsla _createFromRgba(num r, num g, num b, num a) {
     // Convert RGB to hsl.
     // See site <http://easyrgb.com/index.php?X=MATH> for good documentation
     // and color conversion routines.
     r /= 255;
     g /= 255;
     b /= 255;
 
     // Hue, saturation and lightness.
     num h;
     num s;
     num l;
 
     num minRgb = math.min(r, math.min(g, b));
     num maxRgb = math.max(r, math.max(g, b));
     l = (maxRgb + minRgb) / 2;
     if (l <= 0) {
-      return new Hsla(0, 0, l);   // Black;
+      return new Hsla(0, 0, l); // Black;
     }
 
     num vm = maxRgb - minRgb;
     s = vm;
     if (s > 0) {
       s /= (l < 0.5) ? (maxRgb + minRgb) : (2 - maxRgb - minRgb);
     } else {
-      return new Hsla(0, 0, l);   // White
+      return new Hsla(0, 0, l); // White
     }
 
     num r2, g2, b2;
     r2 = (maxRgb - r) / vm;
     g2 = (maxRgb - g) / vm;
     b2 = (maxRgb - b) / vm;
     if (r == maxRgb) {
       h = (g == minRgb) ? 5.0 + b2 : 1 - g2;
     } else if (g == maxRgb) {
       h = (b == minRgb) ? 1 + r2 : 3 - b2;
@@ skipping 35 matching lines @@
    */
   num get lightnessPercentage => (_l * 100).round();
 
   /**
    * Returns number as 0..1
    */
   num get alpha => _a;
 
   bool operator ==(other) => Color.equal(this, other);
 
-  String get cssExpression => (_a == null) ?
-      "hsl($hueDegrees,$saturationPercentage,$lightnessPercentage)" :
-      "hsla($hueDegrees,$saturationPercentage,$lightnessPercentage,$_a)";
+  String get cssExpression => (_a == null)
+      ? "hsl($hueDegrees,$saturationPercentage,$lightnessPercentage)"
+      : "hsla($hueDegrees,$saturationPercentage,$lightnessPercentage,$_a)";
 
   String toHexArgbString() => new Rgba.fromHsla(this).toHexArgbString();
 
   int get argbValue => Color.hexToInt(this.toHexArgbString());
 
   Color get color => new Color.createHsla(_h, _s, _l, _a);
   Rgba get rgba => new Rgba.fromHsla(this);
 
   Hsla darker(num amount) =>
       new Hsla.fromRgba(new Rgba.fromHsla(this).darker(amount));
 
   Hsla lighter(num amount) =>
       new Hsla.fromRgba(new Rgba.fromHsla(this).lighter(amount));
 
   int get hashCode => toHexArgbString().hashCode;
 }
 
-
 /** X,Y position. */
 class PointXY implements _StyleProperty {
   final num x, y;
   const PointXY(this.x, this.y);
 
   String get cssExpression {
     // TODO(terry): TBD
   }
 }
 
-
 // TODO(terry): Implement style and color.
 /**
  * Supports border for measuring with layout.
  */
 class Border implements _StyleProperty {
   final int top, left, bottom, right;
 
   // TODO(terry): Just like CSS, 1-arg -> set all properties, 2-args -> top and
   //               bottom are first arg, left and right are second, 3-args, and
   //               4-args -> tlbr or trbl.
   const Border([this.top, this.left, this.bottom, this.right]);
 
   // TODO(terry): Consider using Size or width and height.
-  Border.uniform(num amount) :
-      top = amount, left = amount, bottom = amount, right = amount;
+  Border.uniform(num amount)
+      : top = amount,
+        left = amount,
+        bottom = amount,
+        right = amount;
 
   int get width => left + right;
   int get height => top + bottom;
 
   String get cssExpression {
-    return (top == left && bottom == right && top == right) ? "${left}px" :
-      "${top != null ? '$top' : '0'}px ${
+    return (top == left && bottom == right && top == right)
+        ? "${left}px"
+        : "${top != null ? '$top' : '0'}px ${
       right != null ? '$right' : '0'}px ${
       bottom != null ? '$bottom' : '0'}px ${
       left != null ? '$left' : '0'}px";
   }
 }
 
-
 /** Font style constants. */
 class FontStyle {
   /** Font style [normal] default. */
   static const String normal = "normal";
   /**
    * Font style [italic] use explicity crafted italic font otherwise inclined
    * on the fly like oblique.
    */
   static const String italic = "italic";
   /**
    * Font style [oblique] is rarely used. The normal style of a font is inclined
    * on the fly to the right by 8-12 degrees.
    */
   static const String oblique = "oblique";
 }
 
-
 /** Font variant constants. */
 class FontVariant {
   /** Font style [normal] default. */
   static const String normal = "normal";
   /** Font variant [smallCaps]. */
   static const String smallCaps = "small-caps";
 }
 
-
 /** Font weight constants values 100, 200, 300, 400, 500, 600, 700, 800, 900. */
 class FontWeight {
   /** Font weight normal [default] */
   static const int normal = 400;
   /** Font weight bold */
   static const int bold = 700;
 
   static const int wt100 = 100;
   static const int wt200 = 200;
   static const int wt300 = 300;
   static const int wt400 = 400;
   static const int wt500 = 500;
   static const int wt600 = 600;
   static const int wt700 = 700;
   static const int wt800 = 800;
   static const int wt900 = 900;
 }
 
-
 /** Generic font family names. */
 class FontGeneric {
   /** Generic family sans-serif font (w/o serifs). */
   static const String sansSerif = "sans-serif";
   /** Generic family serif font. */
   static const String serif = "serif";
   /** Generic family fixed-width font. */
   static const monospace = "monospace";
   /** Generic family emulate handwriting font. */
   static const String cursive = "cursive";
   /** Generic family decorative font. */
   static const String fantasy = "fantasy";
 }
 
-
 /**
  * List of most common font families across different platforms.  Use the
  * collection names in the Font class (e.g., Font.SANS_SERIF, Font.FONT_SERIF,
  * Font.MONOSPACE, Font.CURSIVE or Font.FANTASY).  These work best on all
  * platforms using the fonts that best match availability on each platform.
  * See <http://www.angelfire.com/al4/rcollins/style/fonts.html> for a good
  * description of fonts available between platforms and browsers.
  */
 class FontFamily {
   /** Sans-Serif font for Windows similar to Helvetica on Mac bold/italic. */
@@ skipping 39 matching lines @@
 
   /** Fantasy font on most Mac/Windows/Linux platforms. */
   static const String impact = "impact";
   /** Fantasy font for Windows. */
   static const String webdings = "webdings";
 }
 
 class LineHeight {
   final num height;
   final bool inPixels;
-  const LineHeight(this.height, {this.inPixels : true});
+  const LineHeight(this.height, {this.inPixels: true});
 }
 
 // TODO(terry): Support @font-face fule.
 /**
  * Font style support for size, family, weight, style, variant, and lineheight.
  */
 class Font implements _StyleProperty {
   /** Collection of most common sans-serif fonts in order. */
-  static const List<String> sansSerif = const [FontFamily.arial,
-                                               FontFamily.verdana,
-                                               FontFamily.geneva,
-                                               FontFamily.helvetica,
-                                               FontGeneric.sansSerif];
+  static const List<String> sansSerif = const [
+    FontFamily.arial,
+    FontFamily.verdana,
+    FontFamily.geneva,
+    FontFamily.helvetica,
+    FontGeneric.sansSerif
+  ];
 
   /** Collection of most common serif fonts in order. */
-  static const List<String> serif = const [FontFamily.georgia,
-                                           FontFamily.timesNewRoman,
-                                           FontFamily.times,
-                                           FontGeneric.serif];
+  static const List<String> serif = const [
+    FontFamily.georgia,
+    FontFamily.timesNewRoman,
+    FontFamily.times,
+    FontGeneric.serif
+  ];
   /** Collection of most common monospace fonts in order. */
-  static const List<String> monospace = const [FontFamily.courierNew,
-                                               FontFamily.courier,
-                                               FontGeneric.monospace];
+  static const List<String> monospace = const [
+    FontFamily.courierNew,
+    FontFamily.courier,
+    FontGeneric.monospace
+  ];
   /** Collection of most common cursive fonts in order. */
-  static const List<String> cursive = const [FontFamily.textile,
-                                             FontFamily.appleChancery,
-                                             FontFamily.zaphChancery,
-                                             FontGeneric.fantasy];
+  static const List<String> cursive = const [
+    FontFamily.textile,
+    FontFamily.appleChancery,
+    FontFamily.zaphChancery,
+    FontGeneric.fantasy
+  ];
   /** Collection of most common fantasy fonts in order. */
-  static const List<String> fantasy = const [FontFamily.comicSansMs,
-                                             FontFamily.impact,
-                                             FontFamily.webdings,
-                                             FontGeneric.fantasy];
+  static const List<String> fantasy = const [
+    FontFamily.comicSansMs,
+    FontFamily.impact,
+    FontFamily.webdings,
+    FontGeneric.fantasy
+  ];
 
   // TODO(terry): Should support the values xx-small, small, large, xx-large,
   //              etc. (mapped to a pixel sized font)?
   /** Font size in pixels. */
   final num size;
 
   // TODO(terry): _family should be an immutable list, wrapper class to do this
   //              should exist in Dart.
   /**
    * Family specifies a list of fonts, the browser will sequentially select the
@@ skipping 29 matching lines @@
   // height.  Classic typography suggest the ratio be 1.5.  See
   // <http://www.pearsonified.com/2011/12/golden-ratio-typography.php> and
   // <http://meyerweb.com/eric/thoughts/2008/05/06/line-height-abnormal/>.
   /**
    * Create a font using [size] of font in pixels, [family] name of font(s)
    * using [FontFamily], [style] of the font using [FontStyle], [variant] using
    * [FontVariant], and [lineHeight] extra space (leading) around the font in
    * pixels, if not specified it's 1.2 the font size.
    */
   const Font({this.size, this.family, this.weight, this.style, this.variant,
-              this.lineHeight});
+      this.lineHeight});
 
   /**
    * Merge the two fonts and return the result. See [Style.merge] for
    * more information.
    */
   factory Font.merge(Font a, Font b) {
     if (a == null) return b;
     if (b == null) return a;
     return new Font._merge(a, b);
   }
 
   Font._merge(Font a, Font b)
-    : size = _mergeVal(a.size, b.size),
-      family = _mergeVal(a.family, b.family),
-      weight = _mergeVal(a.weight, b.weight),
-      style = _mergeVal(a.style, b.style),
-      variant = _mergeVal(a.variant, b.variant),
-      lineHeight = _mergeVal(a.lineHeight, b.lineHeight);
+      : size = _mergeVal(a.size, b.size),
+        family = _mergeVal(a.family, b.family),
+        weight = _mergeVal(a.weight, b.weight),
+        style = _mergeVal(a.style, b.style),
+        variant = _mergeVal(a.variant, b.variant),
+        lineHeight = _mergeVal(a.lineHeight, b.lineHeight);
 
   /**
    * Shorthand CSS format for font is:
    *
    *    font-style font-variant font-weight font-size/line-height font-family
    *
    * The font-size and font-family values are required. If any of the other
    * values are missing the default value is used.
    */
   String get cssExpression {
     // TODO(jimhug): include variant, style, other options
     if (weight != null) {
       // TODO(jacobr): is this really correct for lineHeight?
       if (lineHeight != null) {
         return "$weight ${size}px/$lineHeightInPixels $_fontsAsString";
       }
       return '$weight ${size}px $_fontsAsString';
     }
 
     return '${size}px $_fontsAsString';
   }
 
-  Font scale(num ratio) =>
-      new Font(size: size * ratio, family: family, weight: weight, style: style,
-          variant: variant);
+  Font scale(num ratio) => new Font(
+      size: size * ratio,
+      family: family,
+      weight: weight,
+      style: style,
+      variant: variant);
 
   /**
    * The lineHeight, provides an indirect means to specify the leading. The
    * leading is the difference between the font-size height and the (used)
    * value of line height in pixels.  If lineHeight is not specified it's
    * automatically computed as 1.2 of the font size.  Firefox is 1.2, Safari is
    * ~1.2, and CSS suggest a ration from 1 to 1.2 of the font-size when
    * computing line-height. The Font class constructor has the computation for
    * _lineHeight.
    */
@@ skipping 10 matching lines @@
   }
 
   int get hashCode {
     // TODO(jimhug): Lot's of potential collisions here. List of fonts, etc.
     return size.toInt() % family[0].hashCode;
   }
 
   bool operator ==(other) {
     if (other is! Font) return false;
     Font o = other;
-    return o.size == size && o.family == family && o.weight == weight &&
-        o.lineHeight == lineHeight && o.style == style && o.variant == variant;
+    return o.size == size &&
+        o.family == family &&
+        o.weight == weight &&
+        o.lineHeight == lineHeight &&
+        o.style == style &&
+        o.variant == variant;
   }
 
   // TODO(terry): This is fragile should probably just iterate through the list
   //              of fonts construction the font-family string.
   /** Return fonts as a comma seperated list sans the square brackets. */
   String get _fontsAsString {
     String fonts = family.toString();
     return fonts.length > 2 ? fonts.substring(1, fonts.length - 1) : "";
   }
 }
@@ skipping 28 matching lines @@
    */
   const BoxEdge([this.left, this.top, this.right, this.bottom]);
 
   /**
    * Creates a box edge with the specified [top], [right], [bottom], and
    * [left] width. This matches the typical CSS order:
    * <https://developer.mozilla.org/en/CSS/margin>
    * <https://developer.mozilla.org/en/CSS/border-width>
    * <https://developer.mozilla.org/en/CSS/padding>.
    */
-   const BoxEdge.clockwiseFromTop(this.top, this.right, this.bottom, this.left);
+  const BoxEdge.clockwiseFromTop(this.top, this.right, this.bottom, this.left);
 
   /**
    * This is a helper to creates a box edge with the same [left], [top]
    * [right], and [bottom] widths.
    */
   const BoxEdge.uniform(num size)
-    : top = size, left = size, bottom = size, right = size;
+      : top = size,
+        left = size,
+        bottom = size,
+        right = size;
 
   /**
    * Takes a possibly null box edge, with possibly null metrics, and fills
    * them in with 0 instead.
    */
   factory BoxEdge.nonNull(BoxEdge other) {
     if (other == null) return const BoxEdge(0, 0, 0, 0);
     num left = other.left;
     num top = other.top;
     num right = other.right;
@@ skipping 22 matching lines @@
    * Merge the two box edge sizes and return the result. See [Style.merge] for
    * more information.
    */
   factory BoxEdge.merge(BoxEdge x, BoxEdge y) {
     if (x == null) return y;
     if (y == null) return x;
     return new BoxEdge._merge(x, y);
   }
 
   BoxEdge._merge(BoxEdge x, BoxEdge y)
-    : left = _mergeVal(x.left, y.left),
-      top = _mergeVal(x.top, y.top),
-      right = _mergeVal(x.right, y.right),
-      bottom = _mergeVal(x.bottom, y.bottom);
+      : left = _mergeVal(x.left, y.left),
+        top = _mergeVal(x.top, y.top),
+        right = _mergeVal(x.right, y.right),
+        bottom = _mergeVal(x.bottom, y.bottom);
 
   /**
    * The total size of the horizontal edges. Equal to [left] + [right], where
    * null is interpreted as 0px.
    */
   num get width => (left != null ? left : 0) + (right != null ? right : 0);
 
   /**
    * The total size of the vertical edges. Equal to [top] + [bottom], where
    * null is interpreted as 0px.
    */
   num get height => (top != null ? top : 0) + (bottom != null ? bottom : 0);
 }
 
 _mergeVal(x, y) => y != null ? y : x;