jquery.masonry.js

/**
 * jQuery Masonry v2.1.05
 * A dynamic layout plugin for jQuery
 * The flip-side of CSS Floats
 * http://masonry.desandro.com
 *
 * Licensed under the MIT license.
 * Copyright 2012 David DeSandro
 */

/*jshint browser: true, curly: true, eqeqeq: true, forin: false, immed: false, newcap: true, noempty: true, strict: true, undef: true */
/*global jQuery: false */

(function( window, $, undefined ){

  'use strict';

  /*
   * smartresize: debounced resize event for jQuery
   *
   * latest version and complete README available on Github:
   * https://github.com/louisremi/jquery.smartresize.js
   *
   * Copyright 2011 @louis_remi
   * Licensed under the MIT license.
   */

  var $event = $.event,
      resizeTimeout;

  $event.special.smartresize = {
    setup: function() {
      $(this).bind( "resize", $event.special.smartresize.handler );
    },
    teardown: function() {
      $(this).unbind( "resize", $event.special.smartresize.handler );
    },
    handler: function( event, execAsap ) {
      // Save the context
      var context = this,
          args = arguments;

      // set correct event type
      event.type = "smartresize";

      if ( resizeTimeout ) { clearTimeout( resizeTimeout ); }
      resizeTimeout = setTimeout(function() {
        $.event.handle.apply( context, args );
      }, execAsap === "execAsap"? 0 : 100 );
    }
  };

  $.fn.smartresize = function( fn ) {
    return fn ? this.bind( "smartresize", fn ) : this.trigger( "smartresize", ["execAsap"] );
  };



// ========================= Masonry ===============================


  // our "Widget" object constructor
  $.Mason = function( options, element ){
    this.element = $( element );

    this._create( options );
    this._init();
  };

  $.Mason.settings = {
    isResizable: true,
    isDraggable: false,
    dragHandleSelector: null,
    dragClass: null,
    isAnimated: false,
    animationOptions: {
      queue: false,
      duration: 500
    },
    gutterWidth: 0,
    isRTL: false,
    isFitWidth: false,
    containerStyle: {
      position: 'relative'
    },
    wastedSpaceJitter: 75,
    wastedSpacePenalty: 30,
    yJitter: 72
  };

  $.Mason.prototype = {

    _filterFindBricks: function( $elems ) {
      var selector = this.options.itemSelector;
      // if there is a selector
      // filter/find appropriate item elements
      return !selector ? $elems : $elems.filter( selector ).add( $elems.find( selector ) );
    },

    _getBricks: function( $elems ) {
      var $bricks = this._filterFindBricks( $elems )
        .css({ position: 'absolute' })
        .addClass('masonry-brick');
      return $bricks;
    },
    
    // sets up widget
    _create : function( options ) {
      
      this.options = $.extend( true, {}, $.Mason.settings, options );
      this.styleQueue = [];

      // get original styles in case we re-apply them in .destroy()
      var elemStyle = this.element[0].style;
      this.originalStyle = {
        // get height
        height: elemStyle.height || ''
      };
      // get other styles that will be overwritten
      var containerStyle = this.options.containerStyle;
      for ( var prop in containerStyle ) {
        this.originalStyle[ prop ] = elemStyle[ prop ] || '';
      }

      this.element.css( containerStyle );

      this.horizontalDirection = this.options.isRTL ? 'right' : 'left';

      this.offset = {
        x: parseInt( this.element.css( 'padding-' + this.horizontalDirection ), 10 ),
        y: parseInt( this.element.css( 'padding-top' ), 10 )
      };
      
      this.isFluid = this.options.columnWidth && typeof this.options.columnWidth === 'function';

      // add masonry class first time around
      var instance = this;
      setTimeout( function() {
        instance.element.addClass('masonry');
      }, 0 );
      
      // bind resize method
      if ( this.options.isResizable ) {
        $(window).bind( 'smartresize.masonry', function() { 
          instance.resize();
        });
      }


      // need to get bricks
      this.reloadItems();

      // set up dragging
      if (this.options.isDraggable ){
        this._initDrag(this.$bricks);
      }

    },


    // _init fires when instance is first created
    // and when instance is triggered again -> $el.masonry();
    _init : function( callback ) {
      this._getColumns();
      this._reLayout( callback );
      this.element.trigger( "masonry.columncountchange", [this.cols] );
    },

    option: function( key, value ){
      // set options AFTER initialization:
      // signature: $('#foo').bar({ cool:false });
      if ( $.isPlainObject( key ) ){
        this.options = $.extend(true, this.options, key);
      } 
    },
    
    // ====================== General Layout ======================

    // used on collection of atoms (should be filtered, and sorted before )
    // accepts atoms-to-be-laid-out to start with
    layout : function( $bricks, callback ) {
      this.element.trigger('masonry.beforelayout');

      // place each brick
      for (var i=0, len = $bricks.length; i < len; i++) {
        this._placeBrick( $bricks[i] );
      }
      var maxY = Math.max.apply( Math, this.colYs ) + this.offset.y, wastedSpaceItem, wastedSpace = [];
      for (var i=0, len = this.colYs.length; i < len; i++) {
        var wastedHeight = maxY - this.colYs[i] - this.offset.y;
        if ( wastedHeight ) {
          // get the top, height, width, and right/left of a box that takes up the entire area of wasted space.
          var wastedSpaceItem = {
            top: this.colYs[i] + this.offset.y,
            height: wastedHeight,
            width: this.columnWidth
          };
          wastedSpaceItem[ this.horizontalDirection ] = this.columnWidth * i + this.offset.x;
          wastedSpace.push(wastedSpaceItem);
        }
      }
      if ( wastedSpace.length ) {
        this.element.trigger( "masonry.wastedspace", [wastedSpace] );
      }
      
      // set the size of the container
      var containerSize = {};
      containerSize.height = Math.max.apply( Math, this.colYs );
      if ( this.options.isFitWidth ) {
        var unusedCols = 0;
        i = this.cols;
        // count unused columns
        while ( --i ) {
          if ( this.colYs[i] !== 0 ) {
            break;
          }
          unusedCols++;
        }
        // fit container to columns that have been used;
        containerSize.width = (this.cols - unusedCols) * this.columnWidth - this.options.gutterWidth;
      }
      this.styleQueue.push({ $el: this.element, style: containerSize });

      this._processStyleQueue();

      // provide $elems as context for the callback
      if ( callback ) {
        callback.call( $bricks );
      }
      
      this.isLaidOut = true;
      this.element.trigger( "masonry.complete", [wastedSpace] );
    },
    _processStyleQueue: function() {
      // are we animating the layout arrangement?
      // use plugin-ish syntax for css or animate
      var styleFn = !this.isLaidOut ? 'css' : (
            this.options.isAnimated ? 'animate' : 'css'
          ),
          animOpts = this.options.animationOptions;

      // process styleQueue
      var obj;
      for (var i=0, len = this.styleQueue.length; i < len; i++) {
        obj = this.styleQueue[i];
        obj.$el[ styleFn ]( obj.style, animOpts );
      }

      // clear out queue for next time
      this.styleQueue = [];
    },
    // calculates number of columns
    // i.e. this.columnWidth = 200
    _getColumns : function() {
      var container = this.options.isFitWidth ? this.element.parent() : this.element,
          containerWidth = container.width(),
          containerPadding = this.element.outerWidth() - this.element.width();

                         // use fluid columnWidth function if there
      this.columnWidth = this.isFluid ? this.options.columnWidth( containerWidth ) :
                    // if not, how about the explicitly set option?
                    this.options.columnWidth ||
                    // or use the size of the first item
                    this.$bricks.outerWidth(true) ||
                    // if there's no items, use size of container
                    containerWidth;

      this.columnWidth += this.options.gutterWidth;

      this.cols = Math.floor( ( containerWidth + this.options.gutterWidth - containerPadding ) / this.columnWidth );
      this.cols = Math.max( this.cols, 1 );

    },

    // layout logic
    _placeBrick: function( brick ) {
      var $brick = $(brick),
          colSpan, groupCount, groupY, groupColY, j, k, wastedY;

      //how many columns does this brick span
      colSpan = Math.ceil( $brick.outerWidth(true) / this.columnWidth );
      colSpan = Math.min( colSpan, this.cols );

      if ( colSpan === 1 ) {
        // if brick spans only one column, just like singleMode
        groupY = this.colYs;
        // it's impossible for a single column brick to waste space, so fill the wastedY array with zeros.
        wastedY = [];
        for ( var i=0; i < this.colYs.length; i++) wastedY[i] = 0;
      } else {
        // brick spans more than one column
        // how many different places could this brick fit horizontally
        groupCount = this.cols + 1 - colSpan;
        groupY = [];
        wastedY = [];

        // for each group potential horizontal position
        for ( j=0; j < groupCount; j++ ) {
          // make an array of colY values for that one group
          groupColY = this.colYs.slice( j, j+colSpan );
          // and get the max value of the array
          groupY[j] = Math.max.apply( Math, groupColY );
          // find out how much space each column option would waste
          wastedY[j] = 0;
          for( k=0; k < groupColY.length; k++ ) {
            wastedY[j] += (groupY[j] - groupColY[k]);
          }
        }
      }

      // get the minimum wasted Y value from the columns
      var minimumY = Math.min.apply( Math, groupY ),
          minimumWasted = Math.min.apply( Math, wastedY ),
          shortCol = 0,
          potentialColumns = [],
          potentialY = [];
      
      // find the columns that waste the minimum amount of space
      for (var i=0, len = wastedY.length; i < len; i++) {
        var spaceBetweenThisYandMinimum = groupY[i] - minimumY;
        var wastedSpacePenalty = spaceBetweenThisYandMinimum * this.options.wastedSpacePenalty;
        //console.log( wastedSpacePenalty, brick );
        if ( wastedY[i] / colSpan <= minimumWasted + this.options.wastedSpaceJitter - wastedSpacePenalty) {
          potentialColumns.push(i);
          potentialY.push(groupY[i]);
        }
      }
      if (potentialColumns.length === 0) {
        for (var i=0, len = groupY.length+1; i < len; i++) {
          potentialColumns.push(i);
        }
        potentialY = groupY;
      }

      // find the shortest, leftmost column
      minimumY = Math.min.apply( Math, potentialY );
      for (var i=0, len = potentialColumns.length; i < len; i++) {
        if ( potentialY[i] <= minimumY + this.options.yJitter ) {
          shortCol = potentialColumns[i];
          break;
        }
      }
      // position the brick
      var position = {
        top: groupY[shortCol] + this.offset.y
      };
      // position.left or position.right
      position[ this.horizontalDirection ] = this.columnWidth * shortCol + this.offset.x;
      this.styleQueue.push({ $el: $brick, style: position });

      // apply setHeight to necessary columns, triggering wastedspace event if needed.
      var setHeight = groupY[shortCol] + $brick.outerHeight(true),
          setSpan = this.cols + 1 - groupY.length,
          wastedSpaceItem, wastedSpace = [];
      for ( i=0; i < setSpan; i++ ) {
        var wastedHeight = position.top - this.colYs[ shortCol + i ] - this.offset.y;
        if ( wastedHeight ) {
          // get the top, height, width, and right/left of a box that takes up the entire area of wasted space.
          wastedSpaceItem = {
            top: this.colYs[ shortCol + i ] + this.offset.y,
            height: wastedHeight,
            width: this.columnWidth
          };
          wastedSpaceItem[ this.horizontalDirection ] = this.columnWidth * (shortCol+i) + this.offset.x;
          wastedSpace.push(wastedSpaceItem)
        }
        this.colYs[ shortCol + i ] = setHeight;
      }
      if (wastedSpace.length) {
        this.element.trigger( "masonry.wastedspace", [wastedSpace] );
      }

    },
    
    
    resize: function() {
      var prevColCount = this.cols;
      // get updated colCount
      this._getColumns();
      if ( this.isFluid || this.cols !== prevColCount ) {
        // if column count has changed, trigger new layout
        this.element.trigger( "masonry.columncountchange", [this.cols] );
        this._reLayout();
      }
    },
    
    
    _reLayout : function( callback ) {
      // reset columns
      var i = this.cols;
      this.colYs = [];
      while (i--) {
        this.colYs.push( 0 );
      }
      // apply layout logic to all bricks
      this.layout( this.$bricks, callback );
    },
    
    // ====================== Convenience methods ======================
    
    // goes through all children again and gets bricks in proper order
    reloadItems : function() {
      this.$bricks = this._getBricks( this.element.children() );
    },
    
    
    reload : function( callback ) {
      this.reloadItems();
      this._init( callback );
    },
    

    // convienence method for working with Infinite Scroll
    appended : function( $content, isAnimatedFromBottom, callback ) {
      if ( isAnimatedFromBottom ) {
        // set new stuff to the bottom
        this._filterFindBricks( $content ).css({ top: this.element.height() });
        var instance = this;
        setTimeout( function(){
          instance._appended( $content, callback );
        }, 1 );
      } else {
        this._appended( $content, callback );
      }
    },
    
    _appended : function( $content, callback ) {
      var $newBricks = this._getBricks( $content );
      // add new bricks to brick pool
      this.$bricks = this.$bricks.add( $newBricks );
      this.layout( $newBricks, callback );
    },
    
    // removes elements from Masonry widget
    remove : function( $content ) {
      this.$bricks = this.$bricks.not( $content );
      $content.remove();
    },
    
    // destroys widget, returns elements and container back (close) to original style
    destroy : function() {

      this.$bricks
        .removeClass('masonry-brick')
        .each(function(){
          this.style.position = '';
          this.style.top = '';
          this.style.left = '';
        });
      
      // re-apply saved container styles
      var elemStyle = this.element[0].style;
      for ( var prop in this.originalStyle ) {
        elemStyle[ prop ] = this.originalStyle[ prop ];
      }

      this.element
        .unbind('.masonry')
        .removeClass('masonry')
        .removeData('masonry');
      
      $(window).unbind('.masonry');

    },

    _getDistanceBetween : function(point1, point2){
        var dx = point1.x - point2.x,
            dy = point1.y - point2.y;
        return Math.sqrt(dx*dx + dy*dy);
    },

    _getBrickPoint : function($brick){
      var offset = $brick.offset();
      return {
        $brick: $brick,
        x  : offset.left + ($brick.outerWidth()/2),
        y : offset.top + ($brick.outerHeight()/2)
      };
    },

    _getClosestBrick : function(brick){

      var $brick = $(brick),
          _this = this,
          dPoint = this._getBrickPoint($brick),
          closest = null,
          point, dist, $b, last, midpoint;

      // find the index of the closest brick
      this.$bricks.each(function(i, b){

        $b = $(b);
        point = _this._getBrickPoint($b);

        // first check the distance from the brick center
        dist = _this._getDistanceBetween(dPoint, point);

        if(closest === null || dist < closest.dist){
          closest = {
            dist: dist,
            $brick: $b,
            index: (point.x > dPoint.x) ? i : i+1
          };
        }

        // get the distance between the center of the line
        // connecting the current and last block
        if(typeof last !== 'undefined'){
          midpoint = {
            x : (last.x + point.x) / 2,
            y : (last.y + point.y) / 2
          };
          dist = _this._getDistanceBetween(dPoint, midpoint);
          if(dist < closest.dist){
            closest = {
              dist: dist,
              $brick: $b,
              index: (point.x > dPoint.x) ? i : i+1
            };
          }
        }

        last = point;

      });

      return closest;
    },

    _initDrag : function($bricks){

      var _this = this,
          dragged = null,
          pos, closest;

      $bricks.bind('dragstart', function(e) {

        // make sure we're dragging by the right thing
        if(_this.options.dragHandleSelector !== null && !$(e.target).is(_this.options.dragHandleSelector)){
          return false;
        }

        pos = $(this).position();

        // add the dragClass
        if(_this.options.dragClass !== null){
          $(this).addClass(_this.options.dragClass);
        }

        // remove the brick being dragged from the array
        dragged = this;
        _this.$bricks = _this.$bricks.not(this);
        _this._reLayout();

      }).bind('drag', function(e, dd) {

        $(this).css({
          top  : pos.top  + dd.deltaY,
          left : pos.left + dd.deltaX
        });

      }).bind('dragend', function(e) {
        
        // remove the dragClass
        if(_this.options.dragClass !== null){
          $(this).removeClass(_this.options.dragClass);
        }

        // insert the brick back into the array
        closest = _this._getClosestBrick(dragged);
        _this.$bricks.splice(closest.index , 0, dragged);
        dragged = null;

        _this._reLayout();
      });
    }
    
  };
  
  
  // ======================= imagesLoaded Plugin ===============================
  /*!
   * jQuery imagesLoaded plugin v1.1.0
   * http://github.com/desandro/imagesloaded
   *
   * MIT License. by Paul Irish et al.
   */


  // $('#my-container').imagesLoaded(myFunction)
  // or
  // $('img').imagesLoaded(myFunction)

  // execute a callback when all images have loaded.
  // needed because .load() doesn't work on cached images

  // callback function gets image collection as argument
  //  `this` is the container

  $.fn.imagesLoaded = function( callback ) {
    var $this = this,
        $images = $this.find('img').add( $this.filter('img') ),
        len = $images.length,
        blank = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==',
        loaded = [];

    function triggerCallback() {
      callback.call( $this, $images );
    }

    function imgLoaded( event ) {
      var img = event.target;
      if ( img.src !== blank && $.inArray( img, loaded ) === -1 ){
        loaded.push( img );
        if ( --len <= 0 ){
          setTimeout( triggerCallback );
          $images.unbind( '.imagesLoaded', imgLoaded );
        }
      }
    }

    // if no images, trigger immediately
    if ( !len ) {
      triggerCallback();
    }

    $images.bind( 'load.imagesLoaded error.imagesLoaded',  imgLoaded ).each( function() {
      // cached images don't fire load sometimes, so we reset src.
      var src = this.src;
      // webkit hack from http://groups.google.com/group/jquery-dev/browse_thread/thread/eee6ab7b2da50e1f
      // data uri bypasses webkit log warning (thx doug jones)
      this.src = blank;
      this.src = src;
    });

    return $this;
  };


  // helper function for logging errors
  // $.error breaks jQuery chaining
  var logError = function( message ) {
    if ( window.console ) {
      window.console.error( message );
    }
  };
  
  // =======================  Plugin bridge  ===============================
  // leverages data method to either create or return $.Mason constructor
  // A bit from jQuery UI
  //   https://github.com/jquery/jquery-ui/blob/master/ui/jquery.ui.widget.js
  // A bit from jcarousel 
  //   https://github.com/jsor/jcarousel/blob/master/lib/jquery.jcarousel.js

  $.fn.masonry = function( options ) {
    if ( typeof options === 'string' ) {
      // call method
      var args = Array.prototype.slice.call( arguments, 1 );

      this.each(function(){
        var instance = $.data( this, 'masonry' );
        if ( !instance ) {
          logError( "cannot call methods on masonry prior to initialization; " +
            "attempted to call method '" + options + "'" );
          return;
        }
        if ( !$.isFunction( instance[options] ) || options.charAt(0) === "_" ) {
          logError( "no such method '" + options + "' for masonry instance" );
          return;
        }
        // apply method
        instance[ options ].apply( instance, args );
      });
    } else {
      this.each(function() {
        var instance = $.data( this, 'masonry' );
        if ( instance ) {
          // apply options & init
          instance.option( options || {} );
          instance._init();
        } else {
          // initialize new instance
          $.data( this, 'masonry', new $.Mason( options, this ) );
        }
      });
    }
    return this;
  };

})( window, jQuery );