Format samples and samples-dev directories.

samples-dev/swarm/swarm_ui_lib/view/MeasureText.dart

 // Copyright (c) 2011, 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.
 
 part of view;
 
 // TODO(jacobr): handle splitting lines on symbols such as '-' that aren't
 // whitespace but are valid word breaking points.
 /**
  * Utility class to efficiently word break and measure text without requiring
@@ skipping 29 matching lines @@
     return character == ' ' || character == '\t' || character == '\n';
   }
 
   num get typicalCharLength {
     return _typicalCharLength;
   }
 
   String quickTruncate(String text, num lineWidth, int maxLines) {
     int targetLength = lineWidth * maxLines ~/ _typicalCharLength;
     // Advance to next word break point.
-    while(targetLength < text.length && !isWhitespace(text[targetLength])) {
+    while (targetLength < text.length && !isWhitespace(text[targetLength])) {
       targetLength++;
     }
 
     if (targetLength < text.length) {
       return '${text.substring(0, targetLength)}$ELLIPSIS';
     } else {
       return text;
     }
   }
 
   /**
    * Add line broken text as html separated by <br> elements.
    * Returns the number of lines in the output.
    * This function is safe to call with [:sb == null:] in which case just the
    * line count is returned.
    */
-  int addLineBrokenText(StringBuffer sb, String text, num lineWidth,
-                        int maxLines) {
+  int addLineBrokenText(
+      StringBuffer sb, String text, num lineWidth, int maxLines) {
     // Strip surrounding whitespace. This ensures we create zero lines if there
     // is no visible text.
     text = text.trim();
 
     // We can often avoid performing a full line break calculation when only
     // the number of lines and not the actual linebreaks is required.
     if (sb == null) {
       _context.font = font;
       int textWidth = _context.measureText(text).width.toInt();
       // By the pigeon hole principle, the resulting text will require at least
@@ skipping 26 matching lines @@
         if (lines > 1) {
           sb.write('<br>');
         }
         // TODO(jacobr): HTML escape this text.
         sb.write(text.substring(start, end));
       }
     });
     return lines;
   }
 
-  void lineBreak(String text, num lineWidth, int maxLines,
-                 Function callback) {
+  void lineBreak(String text, num lineWidth, int maxLines, Function callback) {
     _context.font = font;
     int lines = 0;
     num currentLength = 0;
     int startIndex = 0;
     int wordStartIndex = null;
     int lastWordEndIndex = null;
     bool lastWhitespace = true;
     // TODO(jacobr): optimize this further.
     // To simplify the logic, we simulate injecting a whitespace character
     // at the end of the string.
     for (int i = 0, len = text.length; i <= len; i++) {
       // Treat the char after the end of the string as whitespace.
       bool whitespace = i == len || isWhitespace(text[i]);
       if (whitespace && !lastWhitespace) {
-        num wordLength = _context.measureText(text.substring(
-            wordStartIndex, i)).width;
+        num wordLength =
+            _context.measureText(text.substring(wordStartIndex, i)).width;
         // TODO(jimhug): Replace the line above with this one to workaround
         //               dartium bug - error: unimplemented code
         // num wordLength = (i - wordStartIndex) * 17;
         currentLength += wordLength;
         if (currentLength > lineWidth) {
           // Edge case:
           // It could be the very first word we ran into was too long for a
           // line in which case  we let it have its own line.
           if (lastWordEndIndex != null) {
             lines++;
             callback(startIndex, lastWordEndIndex, currentLength - wordLength);
           }
           if (lines == maxLines) {
             return;
           }
           startIndex = wordStartIndex;
-          currentLength = wordLength;
+          currentLength = wordLength;
         }
         lastWordEndIndex = i;
         currentLength += _spaceLength;
         wordStartIndex = null;
       } else if (wordStartIndex == null && !whitespace) {
         wordStartIndex = i;
       }
       lastWhitespace = whitespace;
     }
     if (currentLength > 0) {
       callback(startIndex, text.length, currentLength);
     }
   }
 }