masonry-rails 0.2.1 → 0.2.3

data/vendor/assets/javascripts/isotope/item.js

@@ -0,0 +1,75 @@
+/**
+ * Isotope Item
+**/
+
+( function( window ) {
+
+'use strict';
+
+// -------------------------- Item -------------------------- //
+
+function itemDefinition( Outlayer ) {
+
+// sub-class Outlayer Item
+function Item() {
+  Outlayer.Item.apply( this, arguments );
+}
+
+Item.prototype = new Outlayer.Item();
+
+Item.prototype._create = function() {
+  // assign id, used for original-order sorting
+  this.id = this.layout.itemGUID++;
+  Outlayer.Item.prototype._create.call( this );
+  this.sortData = {};
+};
+
+Item.prototype.updateSortData = function() {
+  if ( this.isIgnored ) {
+    return;
+  }
+  // default sorters
+  this.sortData.id = this.id;
+  // for backward compatibility
+  this.sortData['original-order'] = this.id;
+  this.sortData.random = Math.random();
+  // go thru getSortData obj and apply the sorters
+  var getSortData = this.layout.options.getSortData;
+  var sorters = this.layout._sorters;
+  for ( var key in getSortData ) {
+    var sorter = sorters[ key ];
+    this.sortData[ key ] = sorter( this.element, this );
+  }
+};
+
+var _destroy = Item.prototype.destroy;
+Item.prototype.destroy = function() {
+  // call super
+  _destroy.apply( this, arguments );
+  // reset display, #741
+  this.css({
+    display: ''
+  });
+};
+
+return Item;
+
+}
+
+// -------------------------- transport -------------------------- //
+
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( [
+      'outlayer/outlayer'
+    ],
+    itemDefinition );
+} else {
+  // browser global
+  window.Isotope = window.Isotope || {};
+  window.Isotope.Item = itemDefinition(
+    window.Outlayer
+  );
+}
+
+})( window );

data/vendor/assets/javascripts/isotope/layout-mode.js

@@ -0,0 +1,156 @@
+( function( window ) {
+
+'use strict';
+
+// --------------------------  -------------------------- //
+
+function layoutModeDefinition( getSize, Outlayer ) {
+
+  // layout mode class
+  function LayoutMode( isotope ) {
+    this.isotope = isotope;
+    // link properties
+    if ( isotope ) {
+      this.options = isotope.options[ this.namespace ];
+      this.element = isotope.element;
+      this.items = isotope.filteredItems;
+      this.size = isotope.size;
+    }
+  }
+
+  /**
+   * some methods should just defer to default Outlayer method
+   * and reference the Isotope instance as `this`
+  **/
+  ( function() {
+    var facadeMethods = [
+      '_resetLayout',
+      '_getItemLayoutPosition',
+      '_manageStamp',
+      '_getContainerSize',
+      '_getElementOffset',
+      'needsResizeLayout'
+    ];
+
+    for ( var i=0, len = facadeMethods.length; i < len; i++ ) {
+      var methodName = facadeMethods[i];
+      LayoutMode.prototype[ methodName ] = getOutlayerMethod( methodName );
+    }
+
+    function getOutlayerMethod( methodName ) {
+      return function() {
+        return Outlayer.prototype[ methodName ].apply( this.isotope, arguments );
+      };
+    }
+  })();
+
+  // -----  ----- //
+
+  // for horizontal layout modes, check vertical size
+  LayoutMode.prototype.needsVerticalResizeLayout = function() {
+    // don't trigger if size did not change
+    var size = getSize( this.isotope.element );
+    // check that this.size and size are there
+    // IE8 triggers resize on body size change, so they might not be
+    var hasSizes = this.isotope.size && size;
+    return hasSizes && size.innerHeight !== this.isotope.size.innerHeight;
+  };
+
+  // ----- measurements ----- //
+
+  LayoutMode.prototype._getMeasurement = function() {
+    this.isotope._getMeasurement.apply( this, arguments );
+  };
+
+  LayoutMode.prototype.getColumnWidth = function() {
+    this.getSegmentSize( 'column', 'Width' );
+  };
+
+  LayoutMode.prototype.getRowHeight = function() {
+    this.getSegmentSize( 'row', 'Height' );
+  };
+
+  /**
+   * get columnWidth or rowHeight
+   * segment: 'column' or 'row'
+   * size 'Width' or 'Height'
+  **/
+  LayoutMode.prototype.getSegmentSize = function( segment, size ) {
+    var segmentName = segment + size;
+    var outerSize = 'outer' + size;
+    // columnWidth / outerWidth // rowHeight / outerHeight
+    this._getMeasurement( segmentName, outerSize );
+    // got rowHeight or columnWidth, we can chill
+    if ( this[ segmentName ] ) {
+      return;
+    }
+    // fall back to item of first element
+    var firstItemSize = this.getFirstItemSize();
+    this[ segmentName ] = firstItemSize && firstItemSize[ outerSize ] ||
+      // or size of container
+      this.isotope.size[ 'inner' + size ];
+  };
+
+  LayoutMode.prototype.getFirstItemSize = function() {
+    var firstItem = this.isotope.filteredItems[0];
+    return firstItem && firstItem.element && getSize( firstItem.element );
+  };
+
+  // ----- methods that should reference isotope ----- //
+
+  LayoutMode.prototype.layout = function() {
+    this.isotope.layout.apply( this.isotope, arguments );
+  };
+
+  LayoutMode.prototype.getSize = function() {
+    this.isotope.getSize();
+    this.size = this.isotope.size;
+  };
+
+  // -------------------------- create -------------------------- //
+
+  LayoutMode.modes = {};
+
+  LayoutMode.create = function( namespace, options ) {
+
+    function Mode() {
+      LayoutMode.apply( this, arguments );
+    }
+
+    Mode.prototype = new LayoutMode();
+
+    // default options
+    if ( options ) {
+      Mode.options = options;
+    }
+
+    Mode.prototype.namespace = namespace;
+    // register in Isotope
+    LayoutMode.modes[ namespace ] = Mode;
+
+    return Mode;
+  };
+
+
+  return LayoutMode;
+
+}
+
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( [
+      'get-size/get-size',
+      'outlayer/outlayer'
+    ],
+    layoutModeDefinition );
+} else {
+  // browser global
+  window.Isotope = window.Isotope || {};
+  window.Isotope.LayoutMode = layoutModeDefinition(
+    window.getSize,
+    window.Outlayer
+  );
+}
+
+
+})( window );

data/vendor/assets/javascripts/isotope/layout/cells-by-column.js

@@ -0,0 +1,64 @@
+/*!
+ * cellsByColumn layout mode for Isotope
+ * http://isotope.metafizzy.co
+ */
+
+( function( window ) {
+
+'use strict';
+
+function cellsByColumnDefinition( LayoutMode ) {
+
+  var CellsByColumn = LayoutMode.create( 'cellsByColumn' );
+
+  CellsByColumn.prototype._resetLayout = function() {
+    // reset properties
+    this.itemIndex = 0;
+    // measurements
+    this.getColumnWidth();
+    this.getRowHeight();
+    // set rows
+    this.rows = Math.floor( this.isotope.size.innerHeight / this.rowHeight );
+    this.rows = Math.max( this.rows, 1 );
+  };
+
+  CellsByColumn.prototype._getItemLayoutPosition = function( item ) {
+    item.getSize();
+    var col = Math.floor( this.itemIndex / this.rows );
+    var row = this.itemIndex % this.rows;
+    // center item within cell
+    var x = ( col + 0.5 ) * this.columnWidth - item.size.outerWidth / 2;
+    var y = ( row + 0.5 ) * this.rowHeight - item.size.outerHeight / 2;
+    this.itemIndex++;
+    return { x: x, y: y };
+  };
+
+  CellsByColumn.prototype._getContainerSize = function() {
+    return {
+      width: Math.ceil( this.itemIndex / this.rows ) * this.columnWidth
+    };
+  };
+
+  CellsByColumn.prototype.needsResizeLayout = function() {
+    return this.needsVerticalResizeLayout();
+  };
+
+  return CellsByColumn;
+
+}
+
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( [
+      'isotope/js/layout-mode'
+    ],
+    cellsByColumnDefinition );
+} else {
+  // browser global
+  cellsByColumnDefinition(
+    window.Isotope.LayoutMode
+  );
+}
+
+
+})( window );

data/vendor/assets/javascripts/isotope/layout/cells-by-row.js

@@ -0,0 +1,59 @@
+/*!
+ * cellsByRows layout mode for Isotope
+ * http://isotope.metafizzy.co
+ */
+
+( function( window ) {
+
+'use strict';
+
+function cellsByRowDefinition( LayoutMode ) {
+
+  var CellsByRow = LayoutMode.create( 'cellsByRow' );
+
+  CellsByRow.prototype._resetLayout = function() {
+    // reset properties
+    this.itemIndex = 0;
+    // measurements
+    this.getColumnWidth();
+    this.getRowHeight();
+    // set cols
+    this.cols = Math.floor( this.isotope.size.innerWidth / this.columnWidth );
+    this.cols = Math.max( this.cols, 1 );
+  };
+
+  CellsByRow.prototype._getItemLayoutPosition = function( item ) {
+    item.getSize();
+    var col = this.itemIndex % this.cols;
+    var row = Math.floor( this.itemIndex / this.cols );
+    // center item within cell
+    var x = ( col + 0.5 ) * this.columnWidth - item.size.outerWidth / 2;
+    var y = ( row + 0.5 ) * this.rowHeight - item.size.outerHeight / 2;
+    this.itemIndex++;
+    return { x: x, y: y };
+  };
+
+  CellsByRow.prototype._getContainerSize = function() {
+    return {
+      height: Math.ceil( this.itemIndex / this.cols ) * this.rowHeight
+    };
+  };
+
+  return CellsByRow;
+
+}
+
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( [
+      'isotope/js/layout-mode'
+    ],
+    cellsByRowDefinition );
+} else {
+  // browser global
+  cellsByRowDefinition(
+    window.Isotope.LayoutMode
+  );
+}
+
+})( window );

data/vendor/assets/javascripts/isotope/layout/fit-columns.js

@@ -0,0 +1,65 @@
+/*!
+ * fitColumns layout mode for Isotope
+ * http://isotope.metafizzy.co
+ */
+
+( function( window ) {
+
+'use strict';
+
+function fitColumnsDefinition( LayoutMode ) {
+
+  var FitColumns = LayoutMode.create('fitColumns');
+
+  FitColumns.prototype._resetLayout = function() {
+    this.x = 0;
+    this.y = 0;
+    this.maxX = 0;
+  };
+
+  FitColumns.prototype._getItemLayoutPosition = function( item ) {
+    item.getSize();
+
+    // if this element cannot fit in the current row
+    if ( this.y !== 0 && item.size.outerHeight + this.y > this.isotope.size.innerHeight ) {
+      this.y = 0;
+      this.x = this.maxX;
+    }
+
+    var position = {
+      x: this.x,
+      y: this.y
+    };
+
+    this.maxX = Math.max( this.maxX, this.x + item.size.outerWidth );
+    this.y += item.size.outerHeight;
+
+    return position;
+  };
+
+  FitColumns.prototype._getContainerSize = function() {
+    return { width: this.maxX };
+  };
+
+  FitColumns.prototype.needsResizeLayout = function() {
+    return this.needsVerticalResizeLayout();
+  };
+
+  return FitColumns;
+
+}
+
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( [
+      'isotope/js/layout-mode'
+    ],
+    fitColumnsDefinition );
+} else {
+  // browser global
+  fitColumnsDefinition(
+    window.Isotope.LayoutMode
+  );
+}
+
+})( window );

data/vendor/assets/javascripts/isotope/layout/horizontal.js

@@ -0,0 +1,54 @@
+/*!
+ * horizontal layout mode for Isotope
+ * http://isotope.metafizzy.co
+ */
+
+( function( window ) {
+
+'use strict';
+
+function horizontalDefinition( LayoutMode ) {
+
+  var Horizontal = LayoutMode.create( 'horizontal', {
+    verticalAlignment: 0
+  });
+
+  Horizontal.prototype._resetLayout = function() {
+    this.x = 0;
+  };
+
+  Horizontal.prototype._getItemLayoutPosition = function( item ) {
+    item.getSize();
+    var y = ( this.isotope.size.innerHeight - item.size.outerHeight ) *
+      this.options.verticalAlignment;
+    var x = this.x;
+    this.x += item.size.outerWidth;
+    return { x: x, y: y };
+  };
+
+  Horizontal.prototype._getContainerSize = function() {
+    return { width: this.x };
+  };
+
+  Horizontal.prototype.needsResizeLayout = function() {
+    return this.needsVerticalResizeLayout();
+  };
+
+  return Horizontal;
+
+}
+
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( [
+      'isotope/js/layout-mode'
+    ],
+    horizontalDefinition );
+} else {
+  // browser global
+  horizontalDefinition(
+    window.Isotope.LayoutMode
+  );
+}
+
+})( window );