/*
Kwicks for jQuery
Copyright (c) 2008 Jeremy Martin
http://www.jeremymartin.name/projects.php?project=kwicks
Licensed under the MIT license:
http://www.opensource.org/licenses/mit-license.php

Any and all use of this script must be accompanied by this copyright/license notice in its present form.

11/8/2010: version 2.0 - Changed plugin format, updated & added a github repository - Rob Garrison
*/

(function($){
$.kwicks = function(el, options){
// To avoid scope issues, use 'base' instead of 'this'
// to reference this class from internal events and functions.
var base = this;

// Access to jQuery and DOM versions of element
base.$el = $(el).addClass('kwicks');
base.el = el;

// Add a reverse reference to the DOM object
base.$el.data('kwicks', base);

base.init = function(){
base.options = $.extend({},$.kwicks.defaultOptions, options);

base.$kwicks = base.$el.children('li');
base.$el.addClass( (base.options.isVertical) ? 'vertical' : 'horizontal' );
base.size = base.$kwicks.size();

// Variables for events
base.lastActive = base.options.defaultKwick;
base.active = base.options.defaultKwick;
base.$active = base.$kwicks.eq(base.active);

// Default variables
base.WoH = (base.options.isVertical) ? 'height' : 'width'; // WoH = Width or Height
base.LoT = (base.options.isVertical) ? 'top' : 'left'; // LoT = Left or Top
base.normWoH = parseInt( base.$kwicks.eq(0).css(base.WoH), 10); // normWoH = Normal Width or Height
base.preCalcLoTs = []; // preCalcLoTs = pre-calculated Left or Top's
base.aniObj = {};

if (!base.options.max) {
base.options.max = (base.normWoH * base.size) - (base.options.min * (base.size - 1));
} else {
base.options.min = ((base.normWoH * base.size) - base.options.max) / (base.size - 1);
}

// set width of container ul
if (base.options.isVertical) {
base.$el.css({
width : base.$kwicks.eq(0).css('width'),
height : (base.normWoH * base.size) + (base.options.spacing * (base.size - 1))
});
} else {
base.$el.css({
width : (base.normWoH * base.size) + (base.options.spacing * (base.size - 1)),
height : base.$kwicks.eq(0).css('height')
});
}

// pre calculate left or top values for all kwicks but the first and last
// i = index of currently hovered kwick, j = index of kwick we're calculating
for(var i = 0; i < base.size; i++) {
base.preCalcLoTs[i] = [];
// don't need to calculate values for first or last kwick
for(var j = 1; j < base.size - 1; j++) {
if(i == j) {
base.preCalcLoTs[i][j] = base.options.isVertical ? j * base.options.min + (j * base.options.spacing) : j * base.options.min + (j * base.options.spacing);
} else {
base.preCalcLoTs[i][j] = (j <= i ? (j * base.options.min) : (j-1) * base.options.min + base.options.max) + (j * base.options.spacing);
}
}
}

// loop through all kwick elements
base.$kwicks.each(function(i) {
var kwick = $(this);

// add class to each kwick
kwick.addClass('kwick-panel kwick' + (i+1));
// set initial width or height and left or top values
// set first kwick
if (i === 0) {
kwick.css(base.LoT, 0);
}
// set last kwick
else if (i == base.size - 1) {
kwick.css(base.options.isVertical ? 'bottom' : 'right', 0);
}
// set all other kwicks
else {
if (base.options.sticky) {
kwick.css(base.LoT, Math.ceil(base.preCalcLoTs[base.options.defaultKwick][i]));
} else {
kwick.css(base.LoT, Math.ceil((i * base.normWoH) + (i * base.options.spacing)));
}
}
// correct size in sticky mode
if (base.options.sticky) {
if(base.options.defaultKwick == i) {
kwick.css(base.WoH, base.options.max);
kwick.addClass(base.options.activeClass);
} else {
kwick.css(base.WoH, base.options.min);
}
}
kwick.css({
margin: 0,
position: 'absolute'
});

kwick.bind(base.options.event, function(e) {
// ignore if already active
if (kwick.is('.' + base.options.activeClass)) { return; }

// update active variables & trigger event
base.$kwicks.stop().removeClass(base.options.activeClass);
base.lastActive = base.active;
base.$active = kwick;
base.active = base.$kwicks.index(kwick);
kwick.addClass(base.options.activeClass);
base.triggerEvent('init');
base.lastEvent = e.timeStamp;

// calculate previous width or heights and left or top values
var prevWoHs = [], // prevWoHs = previous Widths or Heights
prevLoTs = []; // prevLoTs = previous Left or Tops
for(var j = 0; j < base.size; j++) {
prevWoHs[j] = parseInt( base.$kwicks.eq(j).css(base.WoH), 10);
prevLoTs[j] = parseInt( base.$kwicks.eq(j).css(base.LoT), 10);
}
base.aniObj[base.WoH] = base.options.max;
var maxDif = base.options.max - prevWoHs[i],
prevWoHsMaxDifRatio = prevWoHs[i]/maxDif;

base.triggerEvent('expanding');
kwick.animate(base.aniObj, {
step: function(now) {
// calculate animation completeness as percentage
var percentage = maxDif !== 0 ? now/maxDif - prevWoHsMaxDifRatio : 1;
// adjsut other elements based on percentage
base.$kwicks.each(function(j) {
if (j != i) {
base.$kwicks.eq(j).css(base.WoH, Math.ceil(prevWoHs[j] - ((prevWoHs[j] - base.options.min) * percentage)));
}
if (j > 0 && j < base.size - 1) { // if not the first or last kwick
base.$kwicks.eq(j).css(base.LoT, Math.ceil(prevLoTs[j] - ((prevLoTs[j] - base.preCalcLoTs[i][j]) * percentage)));
}
});
},
duration: base.options.duration,
easing: base.options.easing,
complete: function(){ base.triggerEvent('completed'); }
});
});
});

// Reset (collapse) kwicks panel
if (!base.options.sticky) {
base.$el.bind(base.options.eventClose, function(e) {
// check timestamp - in case both 'event' and 'eventClose' are 'click'
if (e.timeStamp - base.lastEvent < 200) { return; }
base.lastEvent = e.timeStamp;
base.triggerEvent('init');
base.closeKwick();
});
}
};

base.openKwick = function(num){
// I tried pulling the expansion animation out, but the event bindings are
// inside an each loop - which doesn't look right to me, but I'm being lazy.
// So, instead of completely rewritting it, I made this shortcut.
if (/\d/.test(num) && !isNaN(num)) {
var n = parseInt($.trim(num),10); // accepts " 2 "
if (n < 0 || n > base.size - 1) { return; }
base.$kwicks.eq(n).trigger(base.options.event);
}
};

base.closeKwick = function(){
if (base.options.sticky) { return; }
var prevWoHs = [],
prevLoTs = [];
for(var i = 0; i < base.size; i++) {
prevWoHs[i] = parseInt( base.$kwicks.eq(i).css(base.WoH), 10);
prevLoTs[i] = parseInt( base.$kwicks.eq(i).css(base.LoT), 10);
}
base.aniObj[base.WoH] = base.normWoH;
var normDif = base.normWoH - prevWoHs[0];

base.triggerEvent('collapsing');

base.$kwicks
.stop()
.removeClass(base.options.activeClass)
.eq(0).animate(base.aniObj, {
step: function(now) {
var percentage = normDif !== 0 ? (now - prevWoHs[0])/normDif : 1;
for(var i = 1; i < base.size; i++) {
base.$kwicks.eq(i).css(base.WoH, Math.ceil(prevWoHs[i] - ((prevWoHs[i] - base.normWoH) * percentage)));
if(i < base.size - 1) {
base.$kwicks.eq(i).css(base.LoT, Math.ceil(prevLoTs[i] - ((prevLoTs[i] - ((i * base.normWoH) + (i * base.options.spacing))) * percentage)));
}
}
},
duration: base.options.duration,
easing: base.options.easing,
complete: function(){ base.triggerEvent('completed'); }
});
};

// Trigger Kwick events
base.triggerEvent = function(cb){
base.$el.trigger('kwicks-' + cb, base);
if ($.isFunction(base.options[cb])) { base.options[cb](base); }
};

// Methods
base.isActive = function(){
return base.$kwicks.is('.active');
};
base.getActive = function(){
return (base.isActive()) ? base.active : -1;
};

// Run initializer
base.init();
};

$.kwicks.defaultOptions = {
isVertical : false, // Kwicks will align vertically if true
sticky : false, // One kwick will always be expanded if true
defaultKwick : 0, // The initially expanded kwick (if and only if sticky is true). zero based
activeClass : 'active', //
event : 'mouseenter', // The event that triggers the expand effect
eventClose : 'mouseleave', // The event that triggers the collapse effect
spacing : 0, // The width (in pixels) separating each kwick element
duration : 500, // The number of milliseconds required for each animation to complete
easing : 'swing', // Custom animation easing (requires easing plugin if anything other than 'swing' or 'linear')
max : null, // The width or height of a fully expanded kwick element
min : null, // The width or height of a fully collapsed kwick element

init : null, // event called when the event occurs (click or mouseover)
expanding : null, // event called before kwicks expanding animation begins
collapsing : null, // event called before kwicks collapsing animation begins
completed : null // event called when animation completes
};

$.fn.kwicks = function(options){
return this.each(function(){
// don't allow multiple instances
if ($(this).data('kwicks')) { return; }
(new $.kwicks(this, options));
});
};

$.fn.getkwicks = function(){
this.data('kwicks');
};

})(jQuery);