Format samples and samples-dev directories.

samples-dev/swarm/swarm_ui_lib/layout/GridLayout.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 layout;
 
 /**
  * Implements a grid-based layout system based on:
  * [http://dev.w3.org/csswg/css3-grid-align/]
  *
@@ skipping 25 matching lines @@
 //  - The CSS parsing is not 100% complete, see the parser TODOs.
 //  - We don't implement error recovery for invalid combinations of CSS
 //    properties, or invalid CSS property values. Instead we throw an error.
 //
 // TODO(jmesserly): high level performance optimizations we could do:
 //  - Optimize for the common case of spanCount = 1
 //  - Optimize for the vbox/hbox case (1 row or 1 column)
 //  - Optimize for the case of no content sized tracks
 //  - Optimize for the "incremental update" cases
 class GridLayout extends ViewLayout {
-
   /** Configuration parameters defined in CSS. */
   final GridTrackList rows;
   final GridTrackList columns;
   final GridTemplate template;
 
   /** The default sizing for new rows. */
   final TrackSizing rowSizing;
 
   /** The default sizing for new columns. */
   final TrackSizing columnSizing;
 
   /**
    * This stores the grid's size during a layout.
    * Used for rows/columns with % or fr units.
    */
   int _gridWidth, _gridHeight;
 
   /**
    * During a layout, this stores all row/column size information.
    * Because grid-items can implicitly specify their own rows/columns, we can't
    * compute this until we know the set of items.
    */
   List<GridTrack> _rowTracks, _columnTracks;
 
   /** During a layout, tracks which dimension we're processing. */
   Dimension _dimension;
 
   GridLayout(Positionable view)
-    : super(view),
-      rows = _GridTrackParser.parse(view.customStyle['grid-rows']),
-      columns = _GridTrackParser.parse(view.customStyle['grid-columns']),
-      template = _GridTemplateParser.parse(view.customStyle['grid-template']),
-
-      rowSizing = _GridTrackParser.parseTrackSizing(
-          view.customStyle['grid-row-sizing']),
-
-      columnSizing = _GridTrackParser.parseTrackSizing(
-          view.customStyle['grid-column-sizing']) {
-
+      : super(view),
+        rows = _GridTrackParser.parse(view.customStyle['grid-rows']),
+        columns = _GridTrackParser.parse(view.customStyle['grid-columns']),
+        template = _GridTemplateParser.parse(view.customStyle['grid-template']),
+        rowSizing = _GridTrackParser
+            .parseTrackSizing(view.customStyle['grid-row-sizing']),
+        columnSizing = _GridTrackParser
+            .parseTrackSizing(view.customStyle['grid-column-sizing']) {
     _rowTracks = rows != null ? rows.tracks : new List<GridTrack>();
     _columnTracks = columns != null ? columns.tracks : new List<GridTrack>();
   }
 
-
   int get currentWidth => _gridWidth;
   int get currentHeight => _gridHeight;
 
   void cacheExistingBrowserLayout() {
     // We don't need to do anything as we don't rely on the _cachedViewRect
     // when the grid layout is used.
   }
 
   // TODO(jacobr): cleanup this method so that it returns a Future
   // rather than taking a Completer as an argument.
@@ skipping 44 matching lines @@
   /**
    * This is the core Grid Track sizing algorithm. It is run for Grid columns
    * and Grid rows. The goal of the function is to ensure:
    *   1. That each Grid Track satisfies its minSizing
    *   2. That each Grid Track grows from the breadth which satisfied its
    *      minSizing to a breadth which satifies its
    *      maxSizing, subject to RemainingSpace.
    */
   // Note: spec does not correctly doc all the parameters to this function.
   void _computeUsedBreadthOfTracks(List<GridTrack> tracks) {
-
     // TODO(jmesserly): as a performance optimization we could cache this
-    final items = view.childViews
-        .map((view_) => view_.layout)
-        .toList();
+    final items = view.childViews.map((view_) => view_.layout).toList();
     CollectionUtils.sortBy(items, (item) => _getSpanCount(item));
 
     // 1. Initialize per Grid Track variables
     for (final t in tracks) {
       // percentage or length sizing functions will return a value
       // min-content, max-content, or a fraction will be set to 0
       t.usedBreadth = t.minSizing.resolveLength(_getGridContentSize());
       t.maxBreadth = t.maxSizing.resolveLength(_getGridContentSize());
       t.updatedBreadth = 0;
     }
@@ skipping 15 matching lines @@
 
     // 4. Resolve content-based MaxTrackSizingFunctions
     _distributeSpaceBySpanCount(items, ContentSizeMode.MIN, MAX_BREADTH);
 
     _distributeSpaceBySpanCount(items, ContentSizeMode.MAX, MAX_BREADTH);
 
     // 5. Grow all Grid Tracks in GridTracks from their usedBreadth up to their
     //    maxBreadth value until RemainingSpace is exhausted.
     // Note: it's not spec'd what to pass as the accumulator, but usedBreadth
     // seems right.
-    _distributeSpaceToTracks(tracks, _getRemainingSpace(tracks),
-        USED_BREADTH, false);
+    _distributeSpaceToTracks(
+        tracks, _getRemainingSpace(tracks), USED_BREADTH, false);
 
     // Spec wording is confusing about which direction this assignment happens,
     // but this is the way that makes sense.
     for (final t in tracks) {
       t.usedBreadth = t.updatedBreadth;
     }
 
     // 6. Grow all Grid Tracks having a fraction as their maxSizing
     final tempBreadth = _calcNormalizedFractionBreadth(tracks);
     for (final t in tracks) {
-      t.usedBreadth = Math.max(t.usedBreadth,
-          tempBreadth * t.maxSizing.fractionValue);
+      t.usedBreadth =
+          Math.max(t.usedBreadth, tempBreadth * t.maxSizing.fractionValue);
     }
 
     _computeTrackPositions(tracks);
   }
 
   /**
    * Final steps to finish positioning tracks. Takes the track size and uses
    * it to get start and end positions. Also rounds the positions to integers.
    */
   void _computeTrackPositions(List<GridTrack> tracks) {
@@ skipping 29 matching lines @@
 
   /**
    * This method computes a '1fr' value, referred to as the
    * tempBreadth, for a set of Grid Tracks. The value computed
    * will ensure that when the tempBreadth is multiplied by the
    * fractions associated with tracks, that the UsedBreadths of tracks
    * will increase by an amount equal to the maximum of zero and the specified
    * freeSpace less the sum of the current UsedBreadths.
    */
   num _calcNormalizedFractionBreadth(List<GridTrack> tracks) {
-
     final fractionTracks = tracks.where((t) => t.maxSizing.isFraction).toList();
 
     // Note: the spec has various bugs in this function, such as mismatched
     // identifiers and names that aren't defined. For the most part it's
     // possible to figure out the meaning. It's also a bit confused about
     // how to compute spaceNeededFromFractionTracks, but that should just be the
     // set to the remaining free space after usedBreadth is accounted for.
 
     // We use the tempBreadth field to store the normalized fraction breadth
     for (final t in fractionTracks) {
@@ skipping 19 matching lines @@
     return spaceNeededFromFractionTracks / accumulatedFractions;
   }
 
   /**
    * Ensures that for each Grid Track in tracks, a value will be
    * computed, updatedBreadth, that represents the Grid Track's share of
    * freeSpace.
    */
   void _distributeSpaceToTracks(List<GridTrack> tracks, num freeSpace,
       _BreadthAccumulator breadth, bool ignoreMaxBreadth) {
-
     // TODO(jmesserly): in some cases it would be safe to sort the passed in
     // list in place. Not always though.
-    tracks = CollectionUtils.orderBy(tracks,
-        (t) => t.maxBreadth - breadth.getSize(t));
+    tracks = CollectionUtils.orderBy(
+        tracks, (t) => t.maxBreadth - breadth.getSize(t));
 
     // Give each Grid Track an equal share of the space, but without exceeding
     // their maxBreadth values. Because there are different MaxBreadths
     // assigned to the different Grid Tracks, this can result in uneven growth.
     for (int i = 0; i < tracks.length; i++) {
       num share = freeSpace / (tracks.length - i);
       share = Math.min(share, tracks[i].maxBreadth);
       tracks[i].tempBreadth = share;
       freeSpace -= share;
     }
@@ skipping 21 matching lines @@
   /**
    * This function prioritizes the distribution of space driven by Grid Items
    * in content-sized Grid Tracks by the Grid Item's spanCount. That is, Grid
    * Items having a lower spanCount have an opportunity to increase the size of
    * the Grid Tracks they cover before those with larger SpanCounts.
    *
    * Note: items are assumed to be already sorted in increasing span count
    */
   void _distributeSpaceBySpanCount(List<ViewLayout> items,
       ContentSizeMode sizeMode, _BreadthAccumulator breadth) {
-
-    items = items.where((item) =>
-        _hasContentSizedTracks(_getTracks(item), sizeMode, breadth)).toList();
+    items = items
+        .where((item) =>
+            _hasContentSizedTracks(_getTracks(item), sizeMode, breadth))
+        .toList();
 
     var tracks = [];
 
     for (int i = 0; i < items.length; i++) {
       final item = items[i];
 
       final itemTargetSize = item.measureContent(this, _dimension, sizeMode);
 
       final spannedTracks = _getTracks(item);
       _distributeSpaceToTracks(spannedTracks, itemTargetSize, breadth, true);
 
       // Remember that we need to update the sizes on these tracks
       tracks.addAll(spannedTracks);
 
       // Each time we transition to a new spanCount, update any modified tracks
       bool spanCountFinished = false;
       if (i + 1 == items.length) {
         spanCountFinished = true;
       } else if (_getSpanCount(item) != _getSpanCount(items[i + 1])) {
         spanCountFinished = true;
       }
 
       if (spanCountFinished) {
         for (final t in tracks) {
-          breadth.setSize(t,
-            Math.max(breadth.getSize(t), t.updatedBreadth));
+          breadth.setSize(t, Math.max(breadth.getSize(t), t.updatedBreadth));
         }
         tracks = [];
       }
     }
   }
 
   /**
    * Returns true if we have an appropriate content sized dimension, and don't
    * cross a fractional track.
    */
   static bool _hasContentSizedTracks(Iterable<GridTrack> tracks,
       ContentSizeMode sizeMode, _BreadthAccumulator breadth) {
-
     for (final t in tracks) {
       final fn = breadth.getSizingFunction(t);
       if (sizeMode == ContentSizeMode.MAX && fn.isMaxContentSized ||
           sizeMode == ContentSizeMode.MIN && fn.isContentSized) {
-
         // Make sure we don't cross a fractional track
         return tracks.length == 1 || !tracks.any((t_) => t_.isFractional);
       }
     }
     return false;
   }
 
   /** Ensures that the numbered track exists. */
-  void _ensureTrack(List<GridTrack> tracks, TrackSizing sizing,
-      int start, int span) {
+  void _ensureTrack(
+      List<GridTrack> tracks, TrackSizing sizing, int start, int span) {
     // Start is 1-based. Make it 0-based.
     start -= 1;
 
     // Grow the list if needed
     int length = start + span;
     int first = Math.min(start, tracks.length);
     tracks.length = Math.max(tracks.length, length);
 
     // Fill in tracks
     for (int i = first; i < length; i++) {
@@ skipping 97 matching lines @@
 
     final result = new List<GridTrack>(span);
     for (int i = 0; i < span; i++) {
       result[i] = tracks[start + i];
     }
     return result;
   }
 
   int _getSpanCount(ViewLayout item) {
     GridLayoutParams childLayout = item.layoutParams;
-    return (_dimension == Dimension.WIDTH ?
-        childLayout.columnSpan : childLayout.rowSpan);
+    return (_dimension == Dimension.WIDTH
+        ? childLayout.columnSpan
+        : childLayout.rowSpan);
   }
 }