/*
    Common Grid 3.1.3
    
    Copyright (c) 2011 STRAIGHTLINE<http://straightline.jp/> All rights reserved.
*/

/* 
---------------------------------------------------------------------------------------------------
    Adjust Grid
---------------------------------------------------------------------------------------------------
*/
var AdjustGrid = new Class({
	Implements: [Options,Events],
    resizeTimer: null,
    hashListner: null,
    isFirst: true,
    isLoadFirst: true,
    isAdjusting: false,
    curLoadedGridItem: null,
    animationType: {
        fade: 0,
        move: 1,
        fadeContainer: 2
    },
    options: {
        baseURL: null,
        containerIdName: null,
        containerMinWidth: 0,
        containerMaxWidth: 'auto',
        gridItemDelay: 50,
        gridItemLeaveDelay: 50,
        onComplete: function(){},             // after first
        onLoadComplete: function(){},         // after window.load
        onAnimationComplete: function(){},    // after animation
        loadAnimation: true,
        loadAnimationType: 0,
        resizeAnimation: true,
        resizeAnimationType: 1,
        fadeDuration: 500,
        fadeTransition: 'sine:in:out',
        leaveDuration: 500,
        leaveTransition: 'sine:in:out',
        moveDuration: 500,
        moveTransition: 'expo:in:out',
        alignHeight: false,
        fadeOutJump: false,
        ajax: false,
        ajaxGridItemSelector: '.ajax-grid-item',
        ajaxTitleIdName: 'ajax-title',        
        ajaxGridItemOpacity: 0.3,
        onAjaxLoading: function(){},
        onAjaxLoaded: function(){}
    },
    
    initialize: function(options) {
        this.setOptions(options);
        this.isFirst = true;
        
        if (
            this.options.isQueueJumping != null ||
            this.options.rightToLeft != null
        ) {
            alert('disable!');
        }
        if (
            this.options.ajax &&
            this.options.baseURL == null
        ) {
            alert('baseURL is empty!');
        }
        
        if ($(this.options.containerIdName) == null) {
            $$('.grid').each(function(grid) {
                grid.setStyle('opacity', 0);
            });
        } else {
            $(this.options.containerIdName).setStyle('opacity', 0);
        }
        
        if (Browser.ie6) {
            this.options.gridItemDelay = 0;
            this.options.fadeDuration = 0;
            this.options.leaveDuration = 0;
        }
        
        window.addEvent('resize', function() {
            clearTimeout(this.resizeTimer);
            this.resizeTimer = (function() {
                if (this.isAdjusting == false) {
                    this.adjust.apply(this, [
                        this.options.resizeAnimation,
                        this.options.resizeAnimationType
                    ]);
                }
            }.bind(this)).delay(200);
        }.bind(this));
        if (this.options.fadeOutJump) {
            window.addEvent('unload', function() {});
        }

        if (this.options.baseURL && this.options.ajax) {
        
            this.hashListner = new HashListener();
            this.hashListner.addEvent('hashChanged',function(hash){
                this.load.apply(this);
            }.bind(this));
            this.hashListner.currentHash = this.hashListner.getHash();
            this.hashListner.start();
            
            var hash = this.hashListner.getHash().replace(/^!/, '');
            if (hash != '' && hash != '/') {
                this.load.apply(this);
            }
        }
    },
    
    run: function() {
        var animation = this.options.resizeAnimation;
        var animationType = this.options.resizeAnimationType;
        
        if (this.isLoadFirst) {
            animation = this.options.loadAnimation;
            animationType = this.options.loadAnimationType;
            if (document.readyState == 'complete') {
                    this.isLoadFirst = false;
            } else {
                window.addEvent('load', function() {
                    this.isLoadFirst = false;
                    this.adjust.apply(this, [
                        animation, 
                        animationType
                    ]);
                }.bind(this));
            }
        }
        
        if (this.options.baseURL) {
            this.options.baseURL = this.options.baseURL.replace(/\/$/, '');
            
            var grids = $$('.grid');
            if (this.options.ajax) {
                grids.each(function(grid) {
                    var openGridItem = grid.retrieve('openGridItem');
                    grid.getElements(this.options.ajaxGridItemSelector).each(function(gridItem) {
                        if (openGridItem != gridItem) {
                            gridItem.getElements('a').each(function(anchor) {
                                if (anchor.retrieve('clickEvent') == null) {
                                    anchor.store('clickEvent', function(event) {
                                        this.load.apply(this, [grid, gridItem, anchor, event]);
                                    }.bind(this));
                                    anchor.addEvent('click', anchor.retrieve('clickEvent'));
                                }
                            }.bind(this));
                        }
                    }.bind(this));
                }.bind(this));
            }
            
            if (this.options.fadeOutJump) {
                var gridItems = $$('.grid-item');
                if (gridItems.length > 0) {
                    $$('a').each(function(anchor) {
                        var href = anchor.get('href');
                        var splitURL = href.split(this.options.baseURL);
                        if (
                            splitURL.length > 1 && 
                            !href.match(/\.(gif|jpg|jpeg|png|zip)$/i) &&
                            !href.contains('#')
                        ) {
                            if (anchor.retrieve('clickEvent') == null) {
                                anchor.store('clickEvent', function(event) {
                                    event.stop();
                                    
                                    var enableFadeOut = true;
                                    gridItems.each(function(gridItem) {
                                        if (gridItem.getStyle('opacity') < 1) {
                                            enableFadeOut = false;
                                        }
                                    });
                                    
                                    if (enableFadeOut) {
                                        gridItems.reverse().each(function(gridItem, index) {
                                            (function() {
                                                var fx = new Fx.Tween(gridItem, {
                                                    property: 'opacity',
                                                    duration: this.options.leaveDuration,
                                                    transition: this.options.leaveTransition,
                                                    onComplete: function() {
                                                        if (index == gridItems.length - 1) {
                                                            location.href = href;
                                                        }
                                                    }.bind(this)
                                                });
                                                fx.start(0);
                                            }.bind(this)).delay(this.options.gridItemLeaveDelay * index);
                                        }.bind(this));
                                    } else {
                                        location.href = href;                            
                                    }
                                }.bind(this));
                                anchor.addEvent('click', anchor.retrieve('clickEvent'));
                            }
                        }
                    }.bind(this));
                }
            }
        }
        
        this._adjust.apply(this, [animation, animationType]);
    },
    
    load: function(grid, gridItem, anchor, event) {
        if (this.isAdjusting) {
            if (event) {
                event.stop();
            }
            return;
        }

        var href = null;
        var trackURL = null;
        if (anchor) {
            href = anchor.get('href');
        } else {
            href = this.options.baseURL + this.hashListner.getHash().replace(/^!/, '');
        }
        var splitURL = href.split(this.options.baseURL);
        var hash = null;
        if (
            splitURL.length > 1 && 
            !href.match(/\.(gif|jpg|jpeg|png|zip|pdf)$/i) &&
            !href.contains('#')
        ) {
            if (event) {
                event.stop();
            }
            trackURL = splitURL[1];
            hash = '!' + splitURL[1];
            if (hash == '!' || hash == '!/') {
                hash = '';
            }
        } else {
            return;
        }

        if (hash) {
            if (anchor == null) {
                anchor = $(document.body).getElement('a[href=' + href + ']');
                if (anchor) {
                    gridItem = anchor.getParent(this.options.ajaxGridItemSelector);
                    if (gridItem) {
                        grid = gridItem.getParent('.grid');
                    }
                }
            }
            if (grid == null || gridItem == null) {
                return;
            }
            if (grid.retrieve('requesting')) {
                return;
            }
            this.isAdjusting = true;
            
            var baseItem = gridItem.getElement('.grid-content') || gridItem;
            var ajaxItems = baseItem.getChildren();
            var request = new Request({
                method: 'get',
                url: href,
                onRequest: function() {
                    this.fireEvent('ajaxLoading');
                    grid.store('requesting', true);
                    gridItem.addClass('ajax-loading');
                    ajaxItems.each(function(ajaxItem) {
                        if (ajaxItem.getStyle('opacity') != 0) {
                            ajaxItem.setStyle('opacity', this.options.ajaxGridItemOpacity);
                        }
                    }.bind(this));
                }.bind(this),
                onSuccess: function(text, xml) {
                    if (Object.prototype.hasOwnProperty.call(window, '_gaq') && trackURL) {
                        _gaq.push(['_trackPageview', trackURL]);
                    }
                
                    grid.store('requesting', null);
                    gridItem.removeClass('ajax-loading');
    
                    var newElement = new Element('span', { html: text });
                    var openGridItem = newElement.getElement('.grid-item');
                    if (openGridItem == null) {
                        ajaxItems.each(function(ajaxItem) {
                            ajaxItem.setStyle('opacity', 1);
                        });
                        this.fireEvent('ajaxLoaded');
                        this.isAdjusting = false;
                        return;
                    }
                    
                    var curOpenGridItem = grid.retrieve('openGridItem');
                    var curHideGridItem = grid.retrieve('hideGridItem');
                    if (curOpenGridItem && curHideGridItem) {
                        curHideGridItem.setStyles({
                            display: curOpenGridItem.getStyle('display'),
                            top: curOpenGridItem.retrieve('positionTop'),
                            left: curOpenGridItem.retrieve('positionLeft')
                        });
                        curOpenGridItem.destroy();
                    }
                    
                    openGridItem.inject(gridItem, 'after');
                    openGridItem.setStyles({
                        top: gridItem.retrieve('positionTop'),
                        left: gridItem.retrieve('positionLeft'),
                        opacity: 0
                    });
                    grid.store('openGridItem', openGridItem);
                    grid.store('hideGridItem', gridItem);
                    
                    this.curLoadedGridItem = openGridItem;
                    this.curLoadedGridItem.store('refGridItem', gridItem);
                    this.curLoadedGridItem.store('firstSetting', null);
                    gridItem.setStyle('display', 'none');
                    ajaxItems.each(function(ajaxItem) {
                        ajaxItem.setStyle('opacity', 1);
                    });
                    this.isAdjusting = false;
                    this.run.apply(this);
                    
                    var titleElement = newElement.getElementById(this.options.ajaxTitleIdName);
                    var title = null;
                    if (titleElement) {
                        title = titleElement.get('text');
                        titleElement.destroy();
                        openGridItem.store('ajaxTitle', title);
                    }
                    
                    this.fireEvent('ajaxLoaded');
                    
                    this.hashListner.stop();
                    this.hashListner.setHash(hash);
                    this.hashListner.start();
                    if (title) {
                        $(document).title = title;
                    }
                }.bind(this),
                onFailure: function(xhr) {
                    gridItem.set('html', 'error');
                    gridItem.setStyle('opacity', 1);
                }
            });
            request.send('ajax=1');
        } else {
            if (this.curLoadedGridItem == null) {
                return;
            }
            var curOpenGridItem = this.curLoadedGridItem;
            grid = curOpenGridItem.getParent('.grid');
            if (grid) {
                if (grid.retrieve('requesting')) {
                    return;
                }
                var curHideGridItem = grid.retrieve('hideGridItem');
                if (curOpenGridItem && curHideGridItem) {
                    curHideGridItem.setStyles({
                        display: 'block',
                        top: curOpenGridItem.retrieve('positionTop'),
                        left: curOpenGridItem.retrieve('positionLeft')
                    });
                    curOpenGridItem.destroy();
                }
                
                grid.store('openGridItem', null);
                grid.store('hideGridItem', null);
                this.curLoadedGridItem = null;
                this.run.apply(this);
                this.fireEvent('ajaxLoaded');
            }
        }
    },
    
    adjust: function(isAnimation, animationType) {
        var timer = (function() {
            if (this.isFirst == false) {
                clearTimeout(timer);
                this._adjust.apply(this, [isAnimation, animationType]);
            }
        }.bind(this)).periodical(50);
    },
    
    _adjust: function(isAnimation, animationType) {
        this.isAdjusting = true;
        
        var container = $(this.options.containerIdName);
        if (container) {
            var containerMinWidth = this.options.containerMinWidth;
            container.setStyle('position', 'relative');
            var windowWidth = window.getWidth();
            var curContainerWidth = container.getSize().x;
            
            if (container.retrieve('curWindowWidth') != windowWidth) {
                container.store('curWindowWidth', windowWidth);
                if (windowWidth > this.options.containerMaxWidth) {
                    container.setStyle('width', this.options.containerMaxWidth);
                } else if (windowWidth < this.options.containerMinWidth) {
                    container.setStyle('width', this.options.containerMinWidth);
                } else {
                    container.setStyle('width', 'auto');
                }
            }
        }
        
        var grids = $$('.grid');
        if (grids.length == 0) {
            this.fireEvent('animationComplete');
            this.isFirst = false;
            
            if (this.isLoadFirst) {
                this.fireEvent('loadComplete');
                this.isLoadFirst = false;
            }
            return;
        }
        var isLoopBack = false;
        for (var gridIndex = 0; gridIndex < grids.length; gridIndex++) {
            var grid = grids[gridIndex];
            
            if (grid.retrieve('fixed')) {
                continue;
            }
            var isContinue = false;
            var childGrids = grid.getElements('.grid');
            childGrids.each(function(childGrid) {
                if (childGrid.retrieve('fixed') == null) {
                    isContinue = true;
                }
            });
            if (isContinue) {
                continue;
            }
            var parentGrid = grid.getParent('.grid');
            if (parentGrid && parentGrid.retrieve('fixed') == null) {
                isLoopBack = true;
            }
            grid.setStyle('position', 'relative');
            
            var gridItems = grid.getElements('.grid-item');
            var gridWidth = grid.getSize().x;
            var gridMaxHeight = 0;
            var baseGridItemWidth = 0;
            for (var gridItemIndex = 0; gridItemIndex < gridItems.length; gridItemIndex++) {
                var gridItem = gridItems[gridItemIndex];
                if (grid != gridItem.getParent('.grid')) {
                    continue;
                }
                if (gridItem.getStyle('display') == 'none' || gridItem.retrieve('nonDisplay')) {
                    continue;
                }
                
                if (baseGridItemWidth == 0) {
                    baseGridItemWidth = gridItem.getComputedSize().totalWidth;
                } else {
                    baseGridItemWidth = Math.min(baseGridItemWidth, gridItem.getComputedSize().totalWidth);
                }
                gridItem.setStyle('position', 'absolute');
                if (this.options.alignHeight) {
                    gridItem.setStyle('height', 'auto');
                }                
            }

            var gridItemsTable = new Array();
            var gridItemRow = 0;
            var gridItemCol = 0;
            var col = Math.floor(gridWidth / baseGridItemWidth);
            var curCol = 0;
            var upperGridItems = new Array();
            for (var gridItemIndex = 0; gridItemIndex < gridItems.length; gridItemIndex++) {
                var gridItem = gridItems[gridItemIndex];
                if (grid != gridItem.getParent('.grid')) {
                    continue;
                }
                if (gridItem.getStyle('display') == 'none' || gridItem.retrieve('nonDisplay')) {
                    continue;
                }
                
                var bottom = 0;
                var gridItemSize = gridItem.getComputedSize();
                var gridItemWidth = gridItemSize.totalWidth;
                var gridItemHeight = gridItemSize.totalHeight;
                var useCol = Math.ceil(gridItemWidth / baseGridItemWidth);
                var canUseCol = col - useCol;
                var upperGridItem = null;
                if (this.options.alignHeight) {
                    if (curCol >= col || curCol + useCol > col) {
                        curCol = 0;
                    }
                    upperGridItem = upperGridItems[curCol];
                    if (upperGridItem) {
                        bottom = upperGridItem.retrieve('positionBottom');
                    }
                } else {
                    curCol = 0;
                    for (var x = 0; x <= canUseCol; x++) {
                        if (upperGridItems[x] == null) {
                            curCol = x;
                            break;
                        } else if (upperGridItems[x].retrieve('positionBottom') < upperGridItems[curCol].retrieve('positionBottom')) {
                            curCol = x;
                        }
                    }
                    if (useCol == 1) {
                        upperGridItem = upperGridItems[curCol];
                        if (upperGridItem) {
                            bottom = upperGridItem.retrieve('positionBottom');
                        }
                    } else {
                        for (var x = 0; x < useCol; x++) {
                            if (upperGridItems[curCol + x]) {
                                if (upperGridItems[curCol + x].retrieve('positionBottom') > bottom) {
                                    upperGridItem = upperGridItems[curCol + x];
                                    bottom = upperGridItem.retrieve('positionBottom');
                                }
                            }
                        }
                    }
                }
                for (var x = 0; x < useCol; x++) {
                    upperGridItems[curCol + x] = gridItem;
                }
                if (gridItem.retrieve('row') == null) {
                    gridItem.setStyle('opacity', 0);
                }
                gridItem.store('positionLeft', curCol * baseGridItemWidth);
                gridItem.store('positionRight', gridItem.retrieve('positionLeft') + gridItemWidth);
                gridItem.store('positionTop', bottom);
                gridItem.store('positionBottom', gridItem.retrieve('positionTop') + gridItemHeight);
                gridItem.store('row', upperGridItem ? upperGridItem.retrieve('row') + 1 : 0);
                
                if (this.curLoadedGridItem == gridItem) {
                    var refGridItem = this.curLoadedGridItem.retrieve('refGridItem');
                    var refGridItemSize = refGridItem.getComputedSize();
                    gridItem.setStyles({
                        top: refGridItem.retrieve('positionTop'),
                        left: refGridItem.retrieve('positionLeft')
                    });
                    refGridItem.store('positionLeft', gridItem.retrieve('positionLeft'));
                    refGridItem.store('positionRight', gridItem.retrieve('positionLeft') + refGridItemSize.totalWidth);
                    refGridItem.store('positionTop', gridItem.retrieve('positionTop'));
                    refGridItem.store('positionBottom', gridItem.retrieve('positionTop') + refGridItemSize.totalHeight);
                }
                
                if (gridItemsTable[gridItem.retrieve('row')]) {
                    gridItem.store('col', gridItemsTable[gridItem.retrieve('row')].length);
                } else {
                    gridItem.store('col', 0);
                }
                
                if (gridItemsTable[gridItem.retrieve('row')] == null) {
                    gridItemsTable[gridItem.retrieve('row')] = new Array();
                }
                gridItemsTable[gridItem.retrieve('row')][gridItem.retrieve('col')] = gridItem;
                
                gridMaxHeight = Math.max(gridItem.retrieve('positionBottom'), gridMaxHeight);
                if (container) {
                    containerMinWidth = Math.max(gridItem.retrieve('positionRight'), containerMinWidth);
                }
                
                if (this.options.alignHeight) {
                    curCol = curCol + useCol;
                }
            }
            if (this.options.alignHeight) {
                for (var row = 0; row < gridItemsTable.length; row++) {
                    var gridItemMaxHeight = 0;
                    for (var col = 0; col < gridItemsTable[row].length; col++) {
                        var gridItem = gridItemsTable[row][col];
                        var gridItemSize = gridItem.getComputedSize();
                        gridItemMaxHeight = Math.max(gridItemMaxHeight, gridItemSize.totalHeight);
                    }
                    var lowerTop = 0;
                    for (var col = 0; col < gridItemsTable[row].length; col++) {
                        var gridItem = gridItemsTable[row][col];
                        gridItem.setStyle('height', gridItemMaxHeight);
                        lowerTop = gridItem.retrieve('positionTop') + gridItemMaxHeight;
                        gridItem.store('positionBottom', lowerTop);
                        gridMaxHeight = Math.max(gridItem.retrieve('positionBottom'), gridMaxHeight);
                    }
                    var lowerRow = row + 1;
                    if (gridItemsTable[lowerRow]) {
                        for (var col = 0; col < gridItemsTable[lowerRow].length; col++) {
                            var gridItem = gridItemsTable[lowerRow][col];
                            var gridItemSize = gridItem.getComputedSize();
                            gridItem.store('positionTop', lowerTop);
                            gridItem.store('positionBottom', gridItem.retrieve('positionTop') + gridItemHeight);
                        }
                    }
                }
            }
            
            if (this.isFirst) {
                grid.setStyle('height', gridMaxHeight);
            } else {
                grid.set('tween', {
                    property: 'height',
                    duration: 'normal',
                    transition: 'expo:out',
                    link: 'cancel'
                }).get('tween').start(gridMaxHeight);
            }
            grid.store('fixed', true);
            if (isLoopBack) {
                gridIndex = -1;
            }
        }
        
        grids.each(function(grid) {
            grid.eliminate('fixed');
        });
        if (container) {
            container.setStyle('width', curContainerWidth);
        }
        
        var index = 0;
        var gridItems = $$('.grid-item');
        if (container == null) {
            $$('.grid').each(function(grid) {
                grid.setStyle('opacity', 1);
            });
        } else {
            new Fx.Tween(container, {
                property: 'width',
                duration: 'normal',
                transition: 'expo:out',
                link: 'cancel'
            }).start(Math.min(containerMinWidth, (this.options.containerMaxWidth == 'auto' ? containerMinWidth : this.options.containerMaxWidth)));
            if (
                isAnimation == false || 
                isAnimation && animationType != this.animationType.fadeContainer
            ) {
                container.setStyle('opacity', 1);
            }
        }
        
        var adjustComplete = function() {
            this.isAdjusting = false;
            this.fireEvent('animationComplete');
            this.isFirst = false;
            if (this.isLoadFirst) {
                this.fireEvent('loadComplete');
                this.isLoadFirst = false;
            }
        }.bind(this);
        var scrollToGridItem = function() {
            if (this.curLoadedGridItem) {
                new Fx.Tween(this.curLoadedGridItem, {
                    property: 'opacity',
                    duration: this.options.fadeDuration,
                    transition: this.options.fadeTransition
                }).start(1).chain(
                    function() {
                        if (this.curLoadedGridItem.retrieve('firstSetting') == null) {
                            if (this.curLoadedGridItem.getCoordinates().top > window.getScrollTop() + getWindowSize().y) {
                                new Fx.Scroll(window, {
                                    transition: 'expo:out'
                                }).toElement(this.curLoadedGridItem);
                            }
                        }
                        this.curLoadedGridItem.store('firstSetting', true);
                    }.bind(this)
                );
            }
        }.bind(this);
        
        var animationCount = 0;
        gridItems.each(function(gridItem, index) {
            if (isAnimation) {
                var duration;
                var transition;
                if (
                    animationType == null || 
                    animationType == this.animationType.fade ||
                    animationType == this.animationType.fadeContainer
                ) {
                    duration = this.options.fadeDuration;
                    transition = this.options.fadeTransition;
                } else if (animationType == this.animationType.move) {
                    duration = this.options.moveDuration;
                    transition = this.options.moveTransition;
                }
                
                if (animationType == this.animationType.fadeContainer) {
                    gridItem.setStyles({
                        top: gridItem.retrieve('positionTop'),
                        left: gridItem.retrieve('positionLeft'),
                        opacity: 1
                    });
                    if (index == gridItems.length - 1) {
                        if (container) {
                            new Fx.Tween(container, {
                                property: 'opacity',
                                duration: duration,
                                transition: transition,
                                onComplete: function() {
                                    adjustComplete();
                                    scrollToGridItem();
                                }.bind(this)
                            }).start(1);
                        }
                    }
                } else {
                    if (
                        this.isFirst == false &&
                        gridItem.getStyle('top').toInt() == gridItem.retrieve('positionTop') &&
                        gridItem.getStyle('left').toInt() == gridItem.retrieve('positionLeft') &&
                        gridItem.getStyle('opacity') == 1
                    ) {
                        duration = 0;
                    }
    
                    var properties;
                    if (
                        animationType == null || 
                        animationType == this.animationType.fade
                    ) {
                        gridItem.setStyles({
                            top: gridItem.retrieve('positionTop'),
                            left: gridItem.retrieve('positionLeft'),
                            opacity: duration == 0 ? 1 : 0
                        });
                        properties = {
                            opacity: 1
                        };
                    } else if (animationType == this.animationType.move) {
                        if (
                            gridItem == this.curLoadedGridItem &&
                            this.curLoadedGridItem.retrieve('firstSetting') == null
                        ) {
                            gridItem.setStyles({
                                top: gridItem.retrieve('positionTop'),
                                left: gridItem.retrieve('positionLeft'),
                                opacity: 0
                            });
                            properties = {
                                top: gridItem.retrieve('positionTop'),
                                left: gridItem.retrieve('positionLeft')
                            };
                        } else {
                            properties = {
                                top: gridItem.retrieve('positionTop'),
                                left: gridItem.retrieve('positionLeft'),
                                opacity: 1
                            };
                        }
                    }
                    (function() {
                        gridItem.set('morph', {
                            duration: duration,
                            transition: transition,
                            link: 'cancel'
                        }).get('morph').start(properties).chain(
                            function() {
                                if (index == gridItems.length - 1) {
                                    adjustComplete();
                                    scrollToGridItem();
                                }
                            }.bind(this)
                        );
                    }.bind(this)).delay(this.options.gridItemDelay * animationCount);
                    if (duration > 0) {
                        animationCount++;
                    }
                }
            } else {
                gridItem.setStyles({
                    top: gridItem.retrieve('positionTop'),
                    left: gridItem.retrieve('positionLeft'),
                    opacity: 1
                });
                if (index == gridItems.length - 1) {
                    adjustComplete();
                    scrollToGridItem();                
                }
            }
        }.bind(this));

        if (this.isFirst) {
            this.fireEvent('complete');
        }
    }
    
});