Format samples and samples-dev directories.

samples-dev/swarm/swarm_ui_lib/view/PagedViews.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;
 
 class PageState {
   final ObservableValue<int> current;
   final ObservableValue<int> target;
   final ObservableValue<int> length;
-  PageState() :
-    current = new ObservableValue<int>(0),
-    target = new ObservableValue<int>(0),
-    length = new ObservableValue<int>(1);
+  PageState()
+      : current = new ObservableValue<int>(0),
+        target = new ObservableValue<int>(0),
+        length = new ObservableValue<int>(1);
 }
 
 /** Simplifies using a PageNumberView and PagedColumnView together. */
 class PagedContentView extends CompositeView {
   final View content;
   final PageState pages;
 
   PagedContentView(this.content)
-    : super('paged-content'),
-      pages = new PageState() {
+      : super('paged-content'),
+        pages = new PageState() {
     addChild(new PagedColumnView(pages, content));
     addChild(new PageNumberView(pages));
   }
 }
 
 /** Displays current page and a left/right arrow. Used with [PagedColumnView] */
 class PageNumberView extends View {
   final PageState pages;
   Element _label;
   Element _left, _right;
@@ skipping 43 matching lines @@
  * A horizontal scrolling view that snaps to items like [ConveyorView], but only
  * has one child. Instead of scrolling between views, it scrolls between content
  * that flows horizontally in columns. Supports left/right swipe to switch
  * between pages. Can also be used with [PageNumberView].
  *
  * This control assumes that it is styled with fixed or percent width and
  * height, so the content will flow out horizontally. This allows it to compute
  * the number of pages using [:scrollWidth:] and [:offsetWidth:].
  */
 class PagedColumnView extends View {
-
   static const MIN_THROW_PAGE_FRACTION = 0.01;
   final View contentView;
 
   final PageState pages;
 
   Element _container;
   int _columnGap, _columnWidth;
   int _viewportSize;
   Scroller scroller;
 
   PagedColumnView(this.pages, this.contentView) : super();
 
   Element render() {
     final node = new Element.html('''
       <div class="paged-column">
         <div class="paged-column-container"></div>
       </div>''');
     _container = node.querySelector('.paged-column-container');
     _container.nodes.add(contentView.node);
 
     // TODO(jmesserly): if we end up with empty columns on the last page,
     // this causes the last page to end up right justified. But it seems to
     // work reasonably well for both clicking and throwing. So for now, leave
     // the scroller configured the default way.
 
     // TODO(jacobr): use named arguments when available.
-    scroller = new Scroller(
-        _container,
-        false /* verticalScrollEnabled */,
-        true /* horizontalScrollEnabled */,
-        true /* momementumEnabled */,
-        () {
-          return new Size(_getViewLength(_container), 1);
-        },
-        Scroller.FAST_SNAP_DECELERATION_FACTOR);
+    scroller = new Scroller(_container, false /* verticalScrollEnabled */,
+        true /* horizontalScrollEnabled */, true /* momementumEnabled */, () {
+      return new Size(_getViewLength(_container), 1);
+    }, Scroller.FAST_SNAP_DECELERATION_FACTOR);
 
     scroller.onDecelStart.listen(_snapToPage);
     scroller.onScrollerDragEnd.listen(_snapToPage);
     scroller.onContentMoved.listen(_onContentMoved);
     return node;
   }
 
   int _getViewLength(Element element) {
     return _computePageSize(element) * pages.length.value;
   }
@@ skipping 52 matching lines @@
     scheduleMicrotask(() {
       contentView.node.style.height = '${node.offset.height}px';
     });
     _updatePageCount(null);
   }
 
   bool _updatePageCount(Callback callback) {
     int pageLength = 1;
     scheduleMicrotask(() {
       if (_container.scrollWidth > _container.offset.width) {
-        pageLength = (_container.scrollWidth / _computePageSize(_container))
-            .ceil();
+        pageLength =
+            (_container.scrollWidth / _computePageSize(_container)).ceil();
       }
       pageLength = Math.max(pageLength, 1);
 
       int oldPage = pages.target.value;
       int newPage = Math.min(oldPage, pageLength - 1);
 
       // Hacky: make sure a change event always fires.
       // This is so we adjust the 3d transform after resize.
       if (oldPage == newPage) {
         pages.target.value = 0;
@@ skipping 21 matching lines @@
     scheduleMicrotask(() {
       int pageSize = _computePageSize(_container);
       int destination;
       num currentPageNumber = -(current / pageSize).round();
       num pageNumber = -currentTarget / pageSize;
       if (current == currentTarget) {
         // User was just static dragging so round to the nearest page.
         pageNumber = pageNumber.round();
       } else {
         if (currentPageNumber == pageNumber.round() &&
-          (pageNumber - currentPageNumber).abs() > MIN_THROW_PAGE_FRACTION &&
-          -current + _viewportSize < _getViewLength(_container) &&
-          current < 0) {
+            (pageNumber - currentPageNumber).abs() > MIN_THROW_PAGE_FRACTION &&
+            -current + _viewportSize < _getViewLength(_container) &&
+            current < 0) {
           // The user is trying to throw so we want to round up to the
           // nearest page in the direction they are throwing.
           pageNumber = currentTarget < current
-              ? currentPageNumber + 1 : currentPageNumber - 1;
+              ? currentPageNumber + 1
+              : currentPageNumber - 1;
         } else {
           pageNumber = pageNumber.round();
         }
       }
       num translate = -pageNumber * pageSize;
       pages.current.value = pageNumber;
       if (currentTarget != translate) {
         scroller.throwTo(translate, 0);
       } else {
         // Update the target page number when we are done animating.
         pages.target.value = pageNumber;
       }
     });
   }
 
   int _computePageSize(Element element) {
     // Hacky: we need to duplicate the way the columns are being computed,
     // including rounding, to figure out how far to translate the div.
     // See http://www.w3.org/TR/css3-multicol/#column-width
     _viewportSize = element.offset.width;
 
     // Figure out how many columns we're rendering.
     // The algorithm ensures we're bigger than the specified min size.
-    int perPage = Math.max(1,
-        (_viewportSize + _columnGap) ~/ (_columnWidth + _columnGap));
+    int perPage = Math.max(
+        1, (_viewportSize + _columnGap) ~/ (_columnWidth + _columnGap));
 
     // Divide up the viewport between the columns.
     int columnSize = (_viewportSize - (perPage - 1) * _columnGap) ~/ perPage;
 
     // Finally, compute how big each page is, and how far to translate.
     return perPage * (columnSize + _columnGap);
   }
 
   void _onPageSelected() {
     scheduleMicrotask(() {
       int translate = -pages.target.value * _computePageSize(_container);
       scroller.throwTo(translate, 0);
     });
   }
 }