--- /dev/null
+/**
+ * Isotope v1.5.11
+ * An exquisite jQuery plugin for magical layouts
+ * http://isotope.metafizzy.co
+ *
+ * Commercial use requires one-time license fee
+ * http://metafizzy.co/#licenses
+ *
+ * Copyright 2012 David DeSandro / Metafizzy
+ */
+
+/*jshint curly: true, eqeqeq: true, forin: false, immed: false, newcap: true, noempty: true, undef: true */
+/*global window: true, jQuery: true */
+
+(function( window, $, undefined ){
+
+ // get global vars
+ var document = window.document;
+ var Modernizr = window.Modernizr;
+
+ // helper function
+ var capitalize = function( str ) {
+ return str.charAt(0).toUpperCase() + str.slice(1);
+ };
+
+ // ========================= getStyleProperty by kangax ===============================
+ // http://perfectionkills.com/feature-testing-css-properties/
+
+ var prefixes = 'Moz Webkit O Ms'.split(' ');
+
+ var getStyleProperty = function( propName ) {
+ var style = document.documentElement.style,
+ prefixed;
+
+ // test standard property first
+ if ( typeof style[propName] === 'string' ) {
+ return propName;
+ }
+
+ // capitalize
+ propName = capitalize( propName );
+
+ // test vendor specific properties
+ for ( var i=0, len = prefixes.length; i < len; i++ ) {
+ prefixed = prefixes[i] + propName;
+ if ( typeof style[ prefixed ] === 'string' ) {
+ return prefixed;
+ }
+ }
+ };
+
+ var transformProp = getStyleProperty('transform'),
+ transitionProp = getStyleProperty('transitionProperty');
+
+
+ // ========================= miniModernizr ===============================
+ // <3<3<3 and thanks to Faruk and Paul for doing the heavy lifting
+
+ /*!
+ * Modernizr v1.6ish: miniModernizr for Isotope
+ * http://www.modernizr.com
+ *
+ * Developed by:
+ * - Faruk Ates http://farukat.es/
+ * - Paul Irish http://paulirish.com/
+ *
+ * Copyright (c) 2009-2010
+ * Dual-licensed under the BSD or MIT licenses.
+ * http://www.modernizr.com/license/
+ */
+
+ /*
+ * This version whittles down the script just to check support for
+ * CSS transitions, transforms, and 3D transforms.
+ */
+
+ var tests = {
+ csstransforms: function() {
+ return !!transformProp;
+ },
+
+ csstransforms3d: function() {
+ var test = !!getStyleProperty('perspective');
+ // double check for Chrome's false positive
+ if ( test ) {
+ var vendorCSSPrefixes = ' -o- -moz- -ms- -webkit- -khtml- '.split(' '),
+ mediaQuery = '@media (' + vendorCSSPrefixes.join('transform-3d),(') + 'modernizr)',
+ $style = $('<style>' + mediaQuery + '{#modernizr{height:3px}}' + '</style>')
+ .appendTo('head'),
+ $div = $('<div id="modernizr" />').appendTo('html');
+
+ test = $div.height() === 3;
+
+ $div.remove();
+ $style.remove();
+ }
+ return test;
+ },
+
+ csstransitions: function() {
+ return !!transitionProp;
+ }
+ };
+
+ var testName;
+
+ if ( Modernizr ) {
+ // if there's a previous Modernzir, check if there are necessary tests
+ for ( testName in tests) {
+ if ( !Modernizr.hasOwnProperty( testName ) ) {
+ // if test hasn't been run, use addTest to run it
+ Modernizr.addTest( testName, tests[ testName ] );
+ }
+ }
+ } else {
+ // or create new mini Modernizr that just has the 3 tests
+ Modernizr = window.Modernizr = {
+ _version : '1.6ish: miniModernizr for Isotope'
+ };
+
+ var classes = ' ';
+ var result;
+
+ // Run through tests
+ for ( testName in tests) {
+ result = tests[ testName ]();
+ Modernizr[ testName ] = result;
+ classes += ' ' + ( result ? '' : 'no-' ) + testName;
+ }
+
+ // Add the new classes to the <html> element.
+ $('html').addClass( classes );
+ }
+
+
+ // ========================= isoTransform ===============================
+
+ /**
+ * provides hooks for .css({ scale: value, translate: [x, y] })
+ * Progressively enhanced CSS transforms
+ * Uses hardware accelerated 3D transforms for Safari
+ * or falls back to 2D transforms.
+ */
+
+ if ( Modernizr.csstransforms ) {
+
+ // i.e. transformFnNotations.scale(0.5) >> 'scale3d( 0.5, 0.5, 1)'
+ var transformFnNotations = Modernizr.csstransforms3d ?
+ { // 3D transform functions
+ translate : function ( position ) {
+ return 'translate3d(' + position[0] + 'px, ' + position[1] + 'px, 0) ';
+ },
+ scale : function ( scale ) {
+ return 'scale3d(' + scale + ', ' + scale + ', 1) ';
+ }
+ } :
+ { // 2D transform functions
+ translate : function ( position ) {
+ return 'translate(' + position[0] + 'px, ' + position[1] + 'px) ';
+ },
+ scale : function ( scale ) {
+ return 'scale(' + scale + ') ';
+ }
+ }
+ ;
+
+ var setIsoTransform = function ( elem, name, value ) {
+ // unpack current transform data
+ var data = $.data( elem, 'isoTransform' ) || {},
+ newData = {},
+ fnName,
+ transformObj = {},
+ transformValue;
+
+ // i.e. newData.scale = 0.5
+ newData[ name ] = value;
+ // extend new value over current data
+ $.extend( data, newData );
+
+ for ( fnName in data ) {
+ transformValue = data[ fnName ];
+ transformObj[ fnName ] = transformFnNotations[ fnName ]( transformValue );
+ }
+
+ // get proper order
+ // ideally, we could loop through this give an array, but since we only have
+ // a couple transforms we're keeping track of, we'll do it like so
+ var translateFn = transformObj.translate || '',
+ scaleFn = transformObj.scale || '',
+ // sorting so translate always comes first
+ valueFns = translateFn + scaleFn;
+
+ // set data back in elem
+ $.data( elem, 'isoTransform', data );
+
+ // set name to vendor specific property
+ elem.style[ transformProp ] = valueFns;
+ };
+
+ // ==================== scale ===================
+
+ $.cssNumber.scale = true;
+
+ $.cssHooks.scale = {
+ set: function( elem, value ) {
+ // uncomment this bit if you want to properly parse strings
+ // if ( typeof value === 'string' ) {
+ // value = parseFloat( value );
+ // }
+ setIsoTransform( elem, 'scale', value );
+ },
+ get: function( elem, computed ) {
+ var transform = $.data( elem, 'isoTransform' );
+ return transform && transform.scale ? transform.scale : 1;
+ }
+ };
+
+ $.fx.step.scale = function( fx ) {
+ $.cssHooks.scale.set( fx.elem, fx.now+fx.unit );
+ };
+
+
+ // ==================== translate ===================
+
+ $.cssNumber.translate = true;
+
+ $.cssHooks.translate = {
+ set: function( elem, value ) {
+
+ // uncomment this bit if you want to properly parse strings
+ // if ( typeof value === 'string' ) {
+ // value = value.split(' ');
+ // }
+ //
+ // var i, val;
+ // for ( i = 0; i < 2; i++ ) {
+ // val = value[i];
+ // if ( typeof val === 'string' ) {
+ // val = parseInt( val );
+ // }
+ // }
+
+ setIsoTransform( elem, 'translate', value );
+ },
+
+ get: function( elem, computed ) {
+ var transform = $.data( elem, 'isoTransform' );
+ return transform && transform.translate ? transform.translate : [ 0, 0 ];
+ }
+ };
+
+ }
+
+ // ========================= get transition-end event ===============================
+ var transitionEndEvent, transitionDurProp;
+
+ if ( Modernizr.csstransitions ) {
+ transitionEndEvent = {
+ WebkitTransitionProperty: 'webkitTransitionEnd', // webkit
+ MozTransitionProperty: 'transitionend',
+ OTransitionProperty: 'oTransitionEnd',
+ transitionProperty: 'transitionEnd'
+ }[ transitionProp ];
+
+ transitionDurProp = getStyleProperty('transitionDuration');
+ }
+
+ // ========================= smartresize ===============================
+
+ /*
+ * 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() {
+ jQuery.event.handle.apply( context, args );
+ }, execAsap === "execAsap"? 0 : 100 );
+ }
+ };
+
+ $.fn.smartresize = function( fn ) {
+ return fn ? this.bind( "smartresize", fn ) : this.trigger( "smartresize", ["execAsap"] );
+ };
+
+
+
+// ========================= Isotope ===============================
+
+
+ // our "Widget" object constructor
+ $.Isotope = function( options, element, callback ){
+ this.element = $( element );
+
+ this._create( options );
+ this._init( callback );
+ };
+
+ // styles of container element we want to keep track of
+ var isoContainerStyles = [ 'overflow', 'position', 'width', 'height' ];
+
+ var $window = $(window);
+
+ $.Isotope.settings = {
+ resizable: true,
+ layoutMode : 'masonry',
+ containerClass : 'isotope',
+ itemClass : 'isotope-item',
+ hiddenClass : 'isotope-hidden',
+ hiddenStyle: { opacity: 0, scale: 0.001 },
+ visibleStyle: { opacity: 1, scale: 1 },
+ animationEngine: 'best-available',
+ animationOptions: {
+ queue: false,
+ duration: 800
+ },
+ sortBy : 'original-order',
+ sortAscending : true,
+ resizesContainer : true,
+ transformsEnabled: !$.browser.opera, // disable transforms in Opera
+ itemPositionDataEnabled: false
+ };
+
+ $.Isotope.prototype = {
+
+ // sets up widget
+ _create : function( options ) {
+
+ this.options = $.extend( {}, $.Isotope.settings, options );
+
+ this.styleQueue = [];
+ this.elemCount = 0;
+
+ // get original styles in case we re-apply them in .destroy()
+ var elemStyle = this.element[0].style;
+ this.originalStyle = {};
+ for ( var i=0, len = isoContainerStyles.length; i < len; i++ ) {
+ var prop = isoContainerStyles[i];
+ this.originalStyle[ prop ] = elemStyle[ prop ] || '';
+ }
+
+ this.element.css({
+ overflow : 'hidden',
+ position : 'relative'
+ });
+
+ this._updateAnimationEngine();
+ this._updateUsingTransforms();
+
+ // sorting
+ var originalOrderSorter = {
+ 'original-order' : function( $elem, instance ) {
+ instance.elemCount ++;
+ return instance.elemCount;
+ },
+ random : function() {
+ return Math.random();
+ }
+ };
+
+ this.options.getSortData = $.extend( this.options.getSortData, originalOrderSorter );
+
+ // need to get atoms
+ this.reloadItems();
+
+ // get top left position of where the bricks should be
+ this.offset = {
+ left: parseInt( this.element.css('padding-left'), 10 ),
+ top: parseInt( this.element.css('padding-top'), 10 )
+ };
+
+ // add isotope class first time around
+ var instance = this;
+ setTimeout( function() {
+ instance.element.addClass( instance.options.containerClass );
+ }, 0 );
+
+ // bind resize method
+ if ( this.options.resizable ) {
+ $window.bind( 'smartresize.isotope', function() {
+ instance.resize();
+ });
+ }
+
+ // dismiss all click events from hidden events
+ this.element.delegate( '.' + this.options.hiddenClass, 'click', function(){
+ return false;
+ });
+
+ },
+
+ _getAtoms : function( $elems ) {
+ var selector = this.options.itemSelector,
+ // filter & find
+ $atoms = selector ? $elems.filter( selector ).add( $elems.find( selector ) ) : $elems,
+ // base style for atoms
+ atomStyle = { position: 'absolute' };
+
+ if ( this.usingTransforms ) {
+ atomStyle.left = 0;
+ atomStyle.top = 0;
+ }
+
+ $atoms.css( atomStyle ).addClass( this.options.itemClass );
+
+ this.updateSortData( $atoms, true );
+
+ return $atoms;
+ },
+
+ // _init fires when your instance is first created
+ // (from the constructor above), and when you
+ // attempt to initialize the widget again (by the bridge)
+ // after it has already been initialized.
+ _init : function( callback ) {
+
+ this.$filteredAtoms = this._filter( this.$allAtoms );
+ this._sort();
+ this.reLayout( callback );
+
+ },
+
+ option : function( opts ){
+ // change options AFTER initialization:
+ // signature: $('#foo').bar({ cool:false });
+ if ( $.isPlainObject( opts ) ){
+ this.options = $.extend( true, this.options, opts );
+
+ // trigger _updateOptionName if it exists
+ var updateOptionFn;
+ for ( var optionName in opts ) {
+ updateOptionFn = '_update' + capitalize( optionName );
+ if ( this[ updateOptionFn ] ) {
+ this[ updateOptionFn ]();
+ }
+ }
+ }
+ },
+
+ // ====================== updaters ====================== //
+ // kind of like setters
+
+ _updateAnimationEngine : function() {
+ var animationEngine = this.options.animationEngine.toLowerCase().replace( /[ _\-]/g, '');
+ var isUsingJQueryAnimation;
+ // set applyStyleFnName
+ switch ( animationEngine ) {
+ case 'css' :
+ case 'none' :
+ isUsingJQueryAnimation = false;
+ break;
+ case 'jquery' :
+ isUsingJQueryAnimation = true;
+ break;
+ default : // best available
+ isUsingJQueryAnimation = !Modernizr.csstransitions;
+ }
+ this.isUsingJQueryAnimation = isUsingJQueryAnimation;
+ this._updateUsingTransforms();
+ },
+
+ _updateTransformsEnabled : function() {
+ this._updateUsingTransforms();
+ },
+
+ _updateUsingTransforms : function() {
+ var usingTransforms = this.usingTransforms = this.options.transformsEnabled &&
+ Modernizr.csstransforms && Modernizr.csstransitions && !this.isUsingJQueryAnimation;
+
+ // prevent scales when transforms are disabled
+ if ( !usingTransforms ) {
+ delete this.options.hiddenStyle.scale;
+ delete this.options.visibleStyle.scale;
+ }
+
+ this.getPositionStyles = usingTransforms ? this._translate : this._positionAbs;
+ },
+
+
+ // ====================== Filtering ======================
+
+ _filter : function( $atoms ) {
+ var filter = this.options.filter === '' ? '*' : this.options.filter;
+
+ if ( !filter ) {
+ return $atoms;
+ }
+
+ var hiddenClass = this.options.hiddenClass,
+ hiddenSelector = '.' + hiddenClass,
+ $hiddenAtoms = $atoms.filter( hiddenSelector ),
+ $atomsToShow = $hiddenAtoms;
+
+ if ( filter !== '*' ) {
+ $atomsToShow = $hiddenAtoms.filter( filter );
+ var $atomsToHide = $atoms.not( hiddenSelector ).not( filter ).addClass( hiddenClass );
+ this.styleQueue.push({ $el: $atomsToHide, style: this.options.hiddenStyle });
+ }
+
+ this.styleQueue.push({ $el: $atomsToShow, style: this.options.visibleStyle });
+ $atomsToShow.removeClass( hiddenClass );
+
+ return $atoms.filter( filter );
+ },
+
+ // ====================== Sorting ======================
+
+ updateSortData : function( $atoms, isIncrementingElemCount ) {
+ var instance = this,
+ getSortData = this.options.getSortData,
+ $this, sortData;
+ $atoms.each(function(){
+ $this = $(this);
+ sortData = {};
+ // get value for sort data based on fn( $elem ) passed in
+ for ( var key in getSortData ) {
+ if ( !isIncrementingElemCount && key === 'original-order' ) {
+ // keep original order original
+ sortData[ key ] = $.data( this, 'isotope-sort-data' )[ key ];
+ } else {
+ sortData[ key ] = getSortData[ key ]( $this, instance );
+ }
+ }
+ // apply sort data to element
+ $.data( this, 'isotope-sort-data', sortData );
+ });
+ },
+
+ // used on all the filtered atoms
+ _sort : function() {
+
+ var sortBy = this.options.sortBy,
+ getSorter = this._getSorter,
+ sortDir = this.options.sortAscending ? 1 : -1,
+ sortFn = function( alpha, beta ) {
+ var a = getSorter( alpha, sortBy ),
+ b = getSorter( beta, sortBy );
+ // fall back to original order if data matches
+ if ( a === b && sortBy !== 'original-order') {
+ a = getSorter( alpha, 'original-order' );
+
projects / limn-bak.git / commitdiff