'
]
, VERTHORZ = { //note : lead and trail are indexes into TRBL
v: { wh:'height', xy:1, tl:'top', lead:0, trail:2, inv:'h' } //Opts.align = left/center/right
, h: { wh:'width', xy:0, tl:'left', lead:3, trail:1, inv:'v' } //Opts.align = top/middle/bottom
}
, DOCKS = []
, XY = [0, 0] //mouse position from left, mouse position from top
, EMPTYFUNC = function(){}
/** tests to see if an image has an alt attribute that looks like an image path, returning it if found, else false
* @private
* @param {element} el Image element
* @return {string|boolean} Image path or false
*/
, ALT_IMAGE = function(el){
var alt = $(el).attr('alt');
return (alt && (/\.(gif|jpg|jpeg|png)$/i).test(alt)) ? alt : false;
}
/** returns integer numeric of leading digits in string argument
* @private
* @param {string} x String representation of an integer
* @return {integer} Number
*/
, AS_INTEGER = function(x){
var r = parseInt(x, 10);
return isNaN(r) ? 0 : r;
}
/** clears a specified timeout timer
* @private
* @param {Dock} Dock Dock object
* @param {string} x Timer to clear
*/
, CLEAR_TIMER = function(Dock, x){
if(Dock[x]){
window.clearTimeout(Dock[x]);
Dock[x] = null;
}
}
/** translates (without affecting) XY[0] or XY[1] into an offset within div.jqDock
* note: doing it this way means that all attenuation is against the initial (shrunken) image positions,
* but it saves having to find every image's offset() each time the cursor moves or an image changes size!
* @private
* @param {Dock} Dock Dock object
* @return {integer} Translated mouse offset
*/
, DELTA_XY = function(Dock){
var VH = VERTHORZ[Dock.Opts.vh] //convenience
, rtn = 0
, el = Dock.Elem[Dock.Current]
, p;
if(el){
p = el.Pad[VH.lead] + el.Pad[VH.trail]; //element's user-specified padding
//get the difference between the cursor position and the leading edge of the current element's outer wrapper,
//multiply by the full/shrunken ratio, and add the element's pre-calculated offset within div.jqDock...
rtn = Math.floor((XY[VH.xy] - el.Wrap.parent().offset()[VH.tl]) * (p + el.Initial) / (p + el.Major)) + el.Offset;
}
return rtn;
}
/** returns a dock index as indicated by the numeric suffix to the element's id attribute
* @private
* @param {element} el Element to test
* @return {integer} Dock index, -1 if not found
*/
, DOCK_INDEX_FROM_ID = function(el){
return el ? 1 * ( (el.id || '').match(/^jqDock(\d+)$/) || [0,-1] )[1] : -1;
}
/** finds a given IMG's entry within the Elem arrays, across all Docks
* @private
* @param {element} el Element to search for
* @return {object|boolean} False if not found
*/
, FIND_IMAGE = function(el){
var cont = true
, id = DOCKS.length
, idx;
while(cont && id--){
idx = DOCKS[id].Elem.length;
while(cont && idx--){
cont = DOCKS[id].Elem[idx].Img[0] !== el;
}
}
return cont ? !cont : DOCKS[id].Elem[idx];
}
/** the onload handler for images; stores width/height, and runs initDock() (on a timeout) if all images for a dock are loaded
* @private
* @this {element} The image element
* @param {object} ev jQuery event object
*/
, IMAGE_ONLOAD = function(ev){
//store 'large' width and height...
var dock = DOCKS[ev.data.id]
, el = dock.Elem[ev.data.idx];
el.height = this.height;
el.width = this.width;
if(++dock.Loaded >= dock.Elem.length){ //check to see if all images are loaded...
window.setTimeout(function(){ $.jqDock.initDock(ev.data.id); }, 0);
}
}
/** returns an item index as indicated by the numeric suffix to the closest jqDockMouse-classed element
* @private
* @param {element} el Element to start from
* @param {element} context Element that the provider of the item index must be within
* @return {integer} Item index, -1 if not found
*/
, ITEM_INDEX_FROM_CLASS = function(el, context){
var m;
while(el && el.ownerDocument && el !== context){
m = el.className.toString().match(/jqDockMouse(\d+)/);
if(m){
return 1 * m[1];
}
el = el.parentNode;
}
return -1;
}
/** returns an object containing width and height, with the one NOT represented by 'dim'
* being calculated proportionately
* if horizontal menu then attenuation is along horizontal (x) axis, thereby setting the new
* dimension for width, so the one to keep in proportion is height; and vice versa for
* vertical menus, obviously!
* @private
* @param {object} el Element of Elem array
* @param {integer} dim Image dimension
* @param {string} vh Vertical or horizontal
* @return {object} The provided dimension and the proportioned dimension (width and height, but not necessarily respectively!)
*/
, KEEP_PROPORTION = function(el, dim, vh){
var r = {}
, vhwh = VERTHORZ[vh].wh //convenience
, invwh = VERTHORZ[VERTHORZ[vh].inv].wh //convenience
;
r[vhwh] = dim;
r[invwh] = Math.round(dim * el[invwh] / el[vhwh]);
return r;
}
/** a label click handler that triggers its related image's click handler
* @private
* @this {element} The DOM element (label) the handler was bound to
*/
, LABEL_CLICK = function(){
$(this).prev('img').trigger('click');
return false;
}
/** shows/hides a label
* @private
* @param {object} Dock Dock object
* @param {integer} [show] Show label
*/
, LABEL_SHOW = function(Dock, show){
var item = Dock.Elem[Dock.Current];
if(item && Dock.Opts.labels){
item.Label.el[item.Label.txt && show ? 'show' : 'hide']();
}
}
/** re-positions a label if needed
* only labels with middle and/or center alignment need re-positioning because css handles the corners
* @private
* @param {object} Dock Dock object
* @param {integer} show Whether to show the label or not (from Dock.Xpand, if supplied)
*/
, POSITION_LABEL = function(Dock, show){
var labels = Dock.Opts.labels
, VH = VERTHORZ[Dock.Opts.vh]
, el = Dock.Elem[Dock.Current]
, i, j, label, labelElem;
if(el && labels){
label = el.Label;
labelElem = label.el;
//check to see if the information required for a middle/centred label has already been gathered...
//note : middle/centred labels can not be set up while the dock is display:none
if(label.mc){
label.mc = 0;
//if labels are being aligned middle and/or centre then we need to find any user-styled padding and width/height, and
//store the overall dimensions (incl. padding) for this image's label, so that we don't need to do this next time...
for(i in VERTHORZ){
label[i] = labelElem[VERTHORZ[i].wh]();
for(j in {lead:1, trail:1}){
label[i] += AS_INTEGER(labelElem.css('padding' + TRBL[VERTHORZ[i][j]]));
}
}
}
//note: if vertically or horizontally centred then centre is based on the IMAGE only
//note : .xy is 0 on horizontal menus, 1 on vertical menus (and vice versa for [.inv].xy!)...
if(labels.charAt(0) == 'm'){
labelElem.css({top: Math.floor((el[AXES[VERTHORZ[VH.inv].xy]] - label.v) / 2)});
}
if(labels.charAt(1) == 'c'){
labelElem.css({left: Math.floor((el[AXES[VH.xy]] - label.h) / 2)});
}
}
if(show){
LABEL_SHOW(Dock, 1); //show
}
}
/** removes ALL text nodes from the menu, so that we don't get spacing issues between menu elements
* @private
* @param {element} el DOM Element
* @recursive
*/
, REMOVE_TEXT = function(el){
var i = el.childNodes.length, j;
while(i){
j = el.childNodes[--i];
if(j.childNodes && j.childNodes.length){
REMOVE_TEXT(j);
}else if(j.nodeType == 3){
el.removeChild(j);
}
}
}
/** initial display of the menu, copes with visibility:hidden as well as display:none
* @private
* @param {object} Dock Dock object
*/
, REVEAL_MENU = function(Dock){
Dock.Menu.css({visibility:'visible'}).show();
}
/** if appropriate, sets an idle timer to trigger a dockidle
* @private
* @param {object} Dock Dock object
*/
, SET_IDLER = function(Dock){
var idleDelay = Dock.Opts.idle;
if(idleDelay){
CLEAR_TIMER(Dock, 'Idler');
Dock.Idler = window.setTimeout(function(){
Dock.Menu.trigger('dockidle');
}
, idleDelay);
}
}
/** create and append the label; unless the label uses middle/center alignment, this is all the label setup required
* any label setting involving middle/center gets handled in POSITION_LABEL()
* @private
* @param {Dock} Dock Dock object
* @param {object} item Menu item object
* @param {integer} indx Index of menu item within menu
*/
, SET_LABEL = function(Dock, item, indx){
var op = Dock.Opts //convenience
, labels = op.labels //convenience
, label = item.Label //convenience
, posBottom, posRight
;
label.txt = op.setLabel.call(Dock.Menu[0], item.Title, indx);
label.mc = label.mc && !!label.txt;
//labels always get created, but will only be shown if they have content (and labels are enabled!)
label.el = $('
')
.hide().insertAfter(item.Img); //insert after the image element
if(labels && label.txt){
posBottom = labels.charAt(0) == 'b';
posRight = labels.charAt(1) == 'r';
//position the label and give a click handler...
label.el.css({
top: posBottom ? 'auto' : 0
, left: posRight ? 'auto' : 0
, bottom: posBottom ? 0 : 'auto'
, right: posRight ? 0 : 'auto'
}).click(LABEL_CLICK); //NB: the click handler returns false!
}
}
/** calculates the image sizes according to the current (translated) position of the cursor within div.jqDock
* result stored in Final for each menu element
* @private
* @param {integer} id Dock index
* @param {integer} [mxy] Translated cursor offset in main axis
*/
, SET_SIZES = function(id, mxy){
var Dock = DOCKS[id] //convenience
, op = Dock.Opts //convenience
, wh = VERTHORZ[op.vh].wh //convenience
, i = Dock.Elem.length
, el, ab;
//if not forced, use current translated cursor position (main axis)...
mxy = mxy || DELTA_XY(Dock);
while(i){
el = Dock.Elem[--i];
ab = Math.abs(mxy - el.Centre);
//if we're smack on or beyond the attenuation distance then set to the min dim
//ensure Final ends up as an integer to avoid 'flutter'
el.Final = ab < op.distance
? el[wh] - Math.floor((el[wh] - el.Initial) * Math.pow(ab, op.coefficient) / op.attenuation)
: el.Initial;
}
}
/** dummy function, simply returns labelText (for when options.setLabel is not provided)
* @private
* @this {element} original menu element
* @param {string} labelText Current label text for menu option
* @param {integer} indx Index of the menu option within the menu
* @return {string} labelText
*/
, TRANSFORM_LABEL = function(labelText, indx){
return labelText;
}
/** sets the css for an individual image wrapper to effect its change in size
* 'dim' is the new value for the main axis dimension as specified in VERTHORZ[Opts.vh].wh, so
* the margin needs to be applied to the inverse dimension!
* note: 'force' is only set when called from initDock() to do the initial shrink
* @private
* @param {integer} id Dock index
* @param {integer} idx Image index
* @param {integer} dim Main axis dimension of image
* @param {boolean} force Force change even if no size difference
*/
, CHANGE_SIZE = function(id, idx, dim, force){
var Dock = DOCKS[id] //convenience
, el = Dock.Elem[idx] //convenience
, op = Dock.Opts //convenience
, yard = Dock.Yard //convenience
, VH = VERTHORZ[op.vh] //convenience
, invVH = VERTHORZ[VH.inv] //convenience
, srcDiff = el.src != el.altsrc
, bdr, css, diff
;
if(force || el.Major != dim){
//horizontal menus in IE quirks mode require border widths (if any) of the Dock to be added to the Dock's main axis dimension...
bdr = ($.boxModel || op.vh == 'v') ? 0 : Dock.Border[VH.lead] + Dock.Border[VH.trail];
//switch image source to large, if (a) it's different to small source, and (b) this is the first step of an expansion...
if(srcDiff && !force && el.Major == el.Initial){
el.Img[0].src = el.altsrc;
}
Dock.Spread += dim - el.Major; //adjust main axis dimension of dock
css = KEEP_PROPORTION(el, dim, op.vh);
diff = op.size - css[invVH.wh];
//add minor axis margins according to alignment...
//note: where diff is an odd number of pixels, for 'middle' or 'center' alignment put the odd pixel in the 'lead' margin
switch(op.align){
case 'top': case 'left': //set bottom/right margin
css['margin' + TRBL[invVH.trail]] = diff;
break;
case 'middle': case 'center' : //set top/left and bottom/right margins
css['margin' + TRBL[invVH.lead]] = (diff + (diff % 2)) / 2;
css['margin' + TRBL[invVH.trail]] = (diff - (diff % 2)) / 2;
break;
default: // = case 'bottom': case 'right' : //set top/left margin
css['margin' + TRBL[invVH.lead]] = diff;
}
//set dock's main axis dimension (if it's changed, or if force and this is first menu item)...
if (dim != el.Major || (force && !idx)) {
if(op.flow){
//if we ARE running flow, then the wrapper dimensions must be set so as to precisely contain the dock...
yard.parent()[VH.wh](Dock.Spread + Dock.Border[VH.lead] + Dock.Border[VH.trail]);
}
yard[VH.wh](Dock.Spread + bdr);
}
//change image wrapper size and margins...
el.Wrap.css(css);
//set dock's main axis 'lead' offset (not negative!)...
if(!op.flow){
//if we are NOT running flow (which is the default) then the dock needs to be centered within its wrapper...
yard.css(VH.tl, Math.floor(Math.max(0, (Dock[VH.wh] - Dock.Spread) / 2)));
}
//reposition the label if need be...
if(Dock.OnDock){
POSITION_LABEL(Dock);
}
//store new dimensions...
el.Major = dim; //main axis
el.Minor = css[invVH.wh]; //minor axis
//switch image source to small, if (a) it's different to large source, and (b) this was the last step of a shrink...
if(srcDiff && !force && dim == el.Initial){
el.Img[0].src = el.src;
}
css = null;
}
}
/** modifies the target sizes in proportion to 'duration' if still within the 'duration' period following a mouseenter
* calls CHANGE_SIZE() for each menu element (if more than Opts.step ms since mouseenter)
* @private
* @param {integer} id Dock index
* @param {boolean} revers For shrinking (from OFF_DOCK())
*/
, FACTOR_SIZES = function(id, revers){
var Dock = DOCKS[id] //convenience
, op = Dock.Opts //convenience
, VH = VERTHORZ[op.vh]
, lapse = op.duration + op.step
, i = 0 //must go through the elements in logical order
, factor, el, sz;
if(Dock.Stamp){
lapse = (new Date()).getTime() - Dock.Stamp;
//there's no point continually checking Date once op.duration has passed...
if(lapse >= op.duration){
Dock.Stamp = 0;
}
}
if(lapse > op.step){ //only if more than Opts.step ms have passed since last mouseenter/leave
factor = lapse < op.duration ? lapse / op.duration : 0;
while(i < Dock.Elem.length){
el = Dock.Elem[i];
sz = (el.Final - el.Initial) * factor;
if(revers){ //revers is for shrinking, where we're going from Final->Initial instead of Initial->Final
sz = factor ? Math.floor(el.Final - sz) : el.Initial;
}else{
sz = factor ? Math.floor(el.Initial + sz) : el.Final;
}
CHANGE_SIZE(id, i++, sz);
}
//tweak 'best guess':
//having changed all item sizes within the dock, if Spread is greater than main axis dimension, adjust wrap dimension...
if(Dock.Spread > Dock[VH.wh]){
Dock.Yard.parent()[VH.wh](Dock.Spread + Dock.Border[VH.lead] + Dock.Border[VH.trail]);
Dock[VH.wh] = Dock.Spread;
}
}
}
/** called when cursor goes outside menu, and checks for completed shrinking of all menu elements
* calls FACTOR_SIZES() (with revers set) on any menu element that has not finished shrinking
* calls itself on a timer to complete the shrinkage
* @private
* @param {integer} id Dock index
* @param {boolean} noIdle Can idler be set
*/
, OFF_DOCK = function(id, noIdle){
var Dock = DOCKS[id] //convenience
, el = Dock.Elem
, i = el.length
;
if(!Dock.OnDock){
while((i--) && el[i].Major <= el[i].Initial){}
//this is here for no other reason than that early versions of Opera seem to leave
//a 'shadow' residue of the expanded image unless/until Delta is recalculated!...
DELTA_XY(Dock);
if(i < 0){ //complete
//reset everything back to 'at rest' state...
i = el.length;
while(i--){
el[i].Major = el[i].Final = el[i].Initial;
}
Dock.Current = -1;
if(!noIdle){
SET_IDLER(Dock);
}
}else{
FACTOR_SIZES(id, true); //set revers
window.setTimeout(function(){ OFF_DOCK(id, noIdle); }, Dock.Opts.step);
}
}
}
/** checks for completed expansion (if OnDock)
* if not completed, runs SET_SIZES(), FACTOR_SIZES(), and then itself on a timer
* @private
* @param {integer} id Dock index
*/
, OVER_DOCK = function(id){
var Dock = DOCKS[id] //convenience
, el = Dock.Elem
, i = el.length;
if(Dock.OnDock){
while((i--) && el[i].Major >= el[i].Final){}
if(i < 0){ //complete
Dock.Xpand = 1;
LABEL_SHOW(Dock, 1); //show
}else{
SET_SIZES(id);
FACTOR_SIZES(id);
window.setTimeout(function(){ OVER_DOCK(id); }, Dock.Opts.step);
}
}
}
/** actions for any type of mouse event
* @private
* @param {integer} etype Type of event as index into MOUSEEVENTS array
* @param {integer} id Dock id
* @param {integer} idx Menu item id or -1
* @param {boolean} fake Set if called as a result of inactivity
*/
, DO_MOUSE = function(etype, id, idx, fake){
var Dock = DOCKS[id] //convenience
, el = Dock.Elem //convenience
, i = el.length;
switch(etype){
case 0: //mouseenter
Dock.OnDock = 1;
if(Dock.Current >= 0 && Dock.Current !== idx){
LABEL_SHOW(Dock); //hide
}
Dock.Current = idx;
POSITION_LABEL(Dock, Dock.Xpand);
Dock.Stamp = (new Date()).getTime();
SET_SIZES(id);
OVER_DOCK(id); //sets Xpand when complete
break;
case 1: //mousemove
if(idx !== Dock.Current){ //mousemove from one item onto another
LABEL_SHOW(Dock); //hide
Dock.Current = idx;
}
POSITION_LABEL(Dock, Dock.Xpand);
if(Dock.OnDock && Dock.Xpand){
SET_SIZES(id);
FACTOR_SIZES(id);
}
break;
case 2: //mouseleave
CLEAR_TIMER(Dock, 'Inactive');
Dock.OnDock = Dock.Xpand = 0;
LABEL_SHOW(Dock); //hide
Dock.Stamp = (new Date()).getTime();
while(i--){ //just in case...
el[i].Final = el[i].Major;
}
OFF_DOCK(id, !!fake); //clears Current when complete
break;
default:
}
}
/** handler for all bound mouse events (move/enter/leave)
* @private
* @this {element}
* @param {object} ev jQuery Event object
* @return {boolean} false
*/
, MOUSE_HANDLER = function(ev){
var dockId = DOCK_INDEX_FROM_ID(this)
, Dock = DOCKS[dockId]
, idx = Dock ? ITEM_INDEX_FROM_CLASS(ev.target, this) : -1
, doMse = -1
, onDock
;
if(Dock){
if(Dock.Asleep){ //buffer it...
Dock.Sleeper = {
target:ev.target
, type:ev.type
, pageX:ev.pageX
, pageY:ev.pageY
};
}else{
onDock = Dock.OnDock;
CLEAR_TIMER(Dock, 'Idler');
XY = [ev.pageX, ev.pageY];
if(ev.type == MOUSEEVENTS[2]){//=mouseleave
if(onDock){
doMse = 2; //mouseleave
}else{
SET_IDLER(Dock);
}
}else{ //=mousemove or mouseenter...
if(Dock.Opts.inactivity){
CLEAR_TIMER(Dock, 'Inactive');
Dock.Inactive = window.setTimeout(function(){
DO_MOUSE(2, dockId, idx, true); //mouseleave
}, Dock.Opts.inactivity);
}
if(ev.type == MOUSEEVENTS[1]){ //=mousemove
if(idx < 0){
if(onDock && Dock.Current >= 0){ //off of current
doMse = 2; //mouseleave
}
}else if(!onDock || Dock.Current < 0){ //instant re-entry or no current
doMse = 0; //mouseenter
}else{ //change of current or moving within current
doMse = 1; //mousemove
}
}else if(idx >= 0 && !onDock){ //mouseenter...
doMse = 0; //mouseenter
}
}
Dock.Sleeper = null;
if(doMse >= 0){
DO_MOUSE(doMse, dockId, idx);
}
}
}
//v1.5 don't return false, otherwise handlers listening on docksleep and then, for example,
// checking a mouseover on div.jqDock in order to 'bring back' a hidden menu, would
// not receive notification of the mouseover because it would be blocked here
// return false;
}
/** handler for the docknudge and dockidle events
* @private
* @this {element} The original menu DOM element
* @param {object} ev jQuery event object
*/
, LISTENER = function(ev){
var el = $('.jqDock', this).get(0)
, dockId = DOCK_INDEX_FROM_ID(el)
, Dock = DOCKS[ dockId ];
if(Dock){
// attempts to 'nudge' the dock awake...
if(ev.type == 'docknudge'){
//if Asleep, check for onWake returning a false - to stay asleep - and
//trigger a dockwake event if not still asleep...
if(Dock.Asleep && !(Dock.Asleep = (Dock.Opts.onWake.call(this) === false))){
$(this).trigger('dockwake');
}
if(!Dock.Asleep){
//start (or reset) idling now...
SET_IDLER(Dock);
//if we have buffered mouse event, run it...
if(Dock.Sleeper){
MOUSE_HANDLER.call(el, Dock.Sleeper);
}
}
}else if(!Dock.Asleep){ //...must be 'dockidle' event type (which only affects a non-sleeping dock)...
// attempts to send the dock to sleep...
//NB: returning false from onSleep() prevents the dock going to sleep, but
//it does NOT reset the idle timer!
CLEAR_TIMER(Dock, 'Idler'); //needed if triggered by the calling program
if((Dock.Asleep = (Dock.Opts.onSleep.call(Dock.Menu[0]) !== false))){
Dock.Menu.trigger('docksleep');
DO_MOUSE(2, dockId, 0, true); //fake a mouseleave as if it were due to inactivity
}
}
}
}
;
/**
* The main $.jqDock object
* @private
* @return {object}
*/
$.jqDock = (function(){
return {
version : 1.5
, defaults : { //can be set at runtime, per menu
size : 48 //[px] maximum minor axis dimension of image (width or height depending on 'align' : vertical menu = width, horizontal = height)
, distance : 72 //[px] attenuation distance from cursor
, coefficient : 1.5 //attenuation coefficient
, duration : 300 //[ms] duration of initial expansion and off-menu shrinkage
, align : 'bottom' //[top/middle/bottom or left/center/right] fixes horizontal/vertical expansion axis
, labels : 0 //enable/disable display of a label on the current image; (true) to use default position, or string to specify
, source : 0 //function: given scope of relevant image element; passed index of image within menu; required to return image source path, or false to use original
, loader : 0 //overrides useJqLoader if set to 'image' or 'jquery'
, inactivity : 0 //[ms] duration of inactivity (no mouse movement) after which any expanded images will collapse; 0 (zero) disables the inactivity timeout
, fadeIn : 0 //[ms] duration of the fade-in 'reveal' of the jqDocked menu; set to zero for instant 'show'
, fadeLayer : '' //if fadeIn is set, this can change the element that is faded; the default is the entire original menu; alternatives are 'wrap' (.jqDockWrap element) or 'dock' (.jqDock element)
, step : 50 //[ms] the timer interval between each step of shrinkage/expansion
//v1.5 : added setLabel, flow and idle options...
, setLabel : 0 //function for transforming label text (ie. title) when initially building the label;
//this is provided so that if the label requires HTML, the transform function can set
//it rather than having to put it in the title field and thereby make the markup invalid.
//the called function will be given the scope (this) of the original menu element, and will be
//passed 2 arguments: the text of the label, and the (zero-based) index of the option within the menu;
//the function is required to return a string (HTML or plain text)
, flow : 0 //alters the default dock behaviour such that the dock is NOT auto-centered and the wrap
//element (.jqDockWrap, which a relatively positioned) expands and collapses to precisely
//contain the dock (.jqDock); this allows elements positioned around the docked menu to
//adjust their own relative position according to the current state of the docked menu
, idle : 0 //[ms] duration of idle time after the mouse has left the menu (without re-entering, obviously!) before the docksleep event is triggered (on the original menu element)
//v1.5 : added onReady, onSleep and onWake hooks...
, onReady : 0 //function: called with scope of original menu element when dock has been initialised but not yet revealed (ie. before being shown)
//NB: the onReady() function can return false to cancel the 'reveal' of the menu and put the dock to sleep
, onSleep : 0 //function: called with scope of original menu element when dock has been idle for the defined idle period and has therefore gone to sleep
//NB: the onSleep() function can return false to cancel the sleep
, onWake : 0 //function: called with scope of original menu element when dock is 'nudged' awake, but only triggered if the dock was asleep prior to the' nudge'
//NB: the onWake() function can return false to cancel the wake-up (dock stays asleep)
}
, useJqLoader : $.browser.opera || $.browser.safari //use jQuery method for loading images, rather than "new Image()" method
/**
* initDock()
* ==========
* called by the image onload function, it stores and sets image height/width;
* once all images have been loaded, it completes the setup of the dock menu
* note: unless all images get loaded, the menu will stay hidden!
* @this {$.jqDock}
* @param {integer} id Dock index
*/
, initDock : function(id){
//========================================
var Dock = DOCKS[id] //convenience
, op = Dock.Opts //convenience
, VH = VERTHORZ[op.vh] //convenience
, invVH = VERTHORZ[VH.inv] //convenience
, borders = Dock.Border //convenience
, numItems = Dock.Elem.length
, vanillaDiv = VANILLA.join('')
, off = 0
, i = 0
, j, k, el, wh, acc, upad, wrap, callback
, fadeLayer = op.fadeLayer //convenience
;
// things will screw up if we don't clear text nodes...
REMOVE_TEXT(Dock.Menu[0]);
//double wrap, and set some basic styles on the dock elements, otherwise it won't work
Dock.Menu.children()
.each(function(i, kid){
var wrap = Dock.Elem[i].Wrap = $(kid).wrap(vanillaDiv + vanillaDiv + '