mirror of
https://github.com/Combodo/iTop.git
synced 2026-02-13 15:34:12 +01:00
436 lines
13 KiB
JavaScript
436 lines
13 KiB
JavaScript
/*
|
|
* jdMenu 1.3.beta2 (2007-03-06)
|
|
*
|
|
* Copyright (c) 2006,2007 Jonathan Sharp (http://jdsharp.us)
|
|
* Dual licensed under the MIT (MIT-LICENSE.txt)
|
|
* and GPL (GPL-LICENSE.txt) licenses.
|
|
*
|
|
* http://jdsharp.us/
|
|
*
|
|
* Built upon jQuery 1.1.1 (http://jquery.com)
|
|
* This also requires the jQuery dimensions plugin
|
|
*/
|
|
(function($){
|
|
// This will store an element list of all our menu objects
|
|
var jdMenu = [];
|
|
|
|
// Public methods
|
|
$.fn.jdMenu = function(inSettings) {
|
|
var settings = $.extend({}, arguments.callee.defaults, inSettings);
|
|
return this.each(function() {
|
|
jdMenu.push(this);
|
|
$(this).addClass('jd_menu_flag_root');
|
|
this.$settings = $.extend({}, settings, {isVerticalMenu: $(this).is('.jd_menu_vertical')});
|
|
addEvents(this);
|
|
});
|
|
};
|
|
$.fn.jdMenuShow = function() {
|
|
return this.each(function() {
|
|
showMenuLI.apply(this);
|
|
});
|
|
};
|
|
$.fn.jdMenuHide = function() {
|
|
return this.each(function() {
|
|
hideMenuUL.apply(this);
|
|
});
|
|
};
|
|
|
|
// Private methods and logic
|
|
$(window)
|
|
// Bind a click event to hide all visible menus when the document is clicked
|
|
.bind('click', function(){
|
|
$(jdMenu).find('ul:visible').jdMenuHide();
|
|
})
|
|
// Cleanup after ourself by nulling the $settings object
|
|
.bind('unload', function() {
|
|
$(jdMenu).each(function() {
|
|
this.$settings = null;
|
|
});
|
|
});
|
|
|
|
// These are our default settings for this plugin
|
|
$.fn.jdMenu.defaults = {
|
|
activateDelay: 750,
|
|
showDelay: 150,
|
|
hideDelay: 550,
|
|
onShow: null,
|
|
onHideCheck: null,
|
|
onHide: null,
|
|
onAnimate: null,
|
|
onClick: null,
|
|
offsetX: 4,
|
|
offsetY: 2,
|
|
iframe: $.browser.msie
|
|
};
|
|
|
|
// Our special parentsUntil method to get all parents up to and including the matched element
|
|
$.fn.parentsUntil = function(match) {
|
|
var a = [];
|
|
$(this[0]).parents().each(function() {
|
|
a.push(this);
|
|
return !$(this).is(match);
|
|
});
|
|
return this.pushStack(a, arguments);
|
|
};
|
|
|
|
// Returns our settings object for this menu
|
|
function getSettings(el) {
|
|
return $(el).parents('ul.jd_menu_flag_root')[0].$settings;
|
|
}
|
|
|
|
// Unbind any events and then rebind them
|
|
function addEvents(ul) {
|
|
removeEvents(ul);
|
|
$('> li', ul)
|
|
.hover(hoverOverLI, hoverOutLI)
|
|
.bind('click', itemClick)
|
|
.find('> a.accessible')
|
|
.bind('click', accessibleClick);
|
|
};
|
|
|
|
// Remove all events for this menu
|
|
function removeEvents(ul) {
|
|
$('> li', ul)
|
|
.unbind('mouseover').unbind('mouseout')
|
|
.unbind('click')
|
|
.find('> a.accessible')
|
|
.unbind('click');
|
|
};
|
|
|
|
function hoverOverLI() {
|
|
var cls = 'jd_menu_hover' + ($(this).parent().is('.jd_menu_flag_root') ? '_menubar' : '');
|
|
$(this).addClass(cls).find('> a').addClass(cls);
|
|
|
|
if (this.$timer) {
|
|
clearTimeout(this.$timer);
|
|
}
|
|
|
|
// Do we have a sub menu?
|
|
if ($('> ul', this).size() > 0) {
|
|
var settings = getSettings(this);
|
|
|
|
// Which delay to use, the longer activate one or the shorter show delay if a menu is already visible
|
|
var delay = ($(this).parents('ul.jd_menu_flag_root').find('ul:visible').size() == 0)
|
|
? settings.activateDelay : settings.showDelay;
|
|
var t = this;
|
|
this.$timer = setTimeout(function() {
|
|
showMenuLI.apply(t);
|
|
}, delay);
|
|
}
|
|
};
|
|
|
|
function hoverOutLI() {
|
|
// Remove both classes so we do not have to test which one we are
|
|
$(this) .removeClass('jd_menu_hover').removeClass('jd_menu_hover_menubar')
|
|
.find('> a')
|
|
.removeClass('jd_menu_hover').removeClass('jd_menu_hover_menubar');
|
|
|
|
if (this.$timer) {
|
|
clearTimeout(this.$timer);
|
|
}
|
|
|
|
// TODO: Possible bug with our test for visibility in that parent menus are hidden child menus are not
|
|
|
|
// If we have a visible menu, hide it
|
|
if ($(this).is(':visible') && $('> ul', this).size() > 0) {
|
|
var settings = getSettings(this);
|
|
var ul = $('> ul', this)[0];
|
|
this.$timer = setTimeout(function() {
|
|
hideMenuUL.apply(ul);
|
|
}, settings.hideDelay);
|
|
}
|
|
};
|
|
|
|
// "this" is a reference to the LI element that contains
|
|
// the UL that will be shown
|
|
function showMenuLI() {
|
|
var ul = $('> ul', this).get(0);
|
|
// We are already visible, just return
|
|
if ($(ul).is(':visible')) {
|
|
return false;
|
|
}
|
|
|
|
// Clear our timer if it exists
|
|
if (this.$timer) {
|
|
clearTimeout(this.$timer);
|
|
}
|
|
|
|
// Get our settings object
|
|
var settings = getSettings(this);
|
|
|
|
// Call our callback
|
|
if (settings.onShow != null && settings.onShow.apply(this) == false) {
|
|
return false;
|
|
}
|
|
|
|
// Add hover classes, needed for accessible functionality
|
|
var isRoot = $(this).parent().is('.jd_menu_flag_root');
|
|
var c = 'jd_menu_active' + (isRoot ? '_menubar' : '');
|
|
$(this).addClass(c).find('> a').addClass(c);
|
|
|
|
if (!isRoot) {
|
|
// Add the active class to the parent list item which maybe our menubar
|
|
var c = 'jd_menu_active' + ($(this).parent().parent().parent().is('.jd_menu_flag_root') ? '_menubar' : '');
|
|
$(this).parent().parent().addClass(c).find('> a').addClass(c);
|
|
}
|
|
|
|
// Hide any existing menues at the same level
|
|
$(this).parent().find('> li > ul:visible').not(ul).each(function() {
|
|
hideMenuUL.apply(this);
|
|
});
|
|
|
|
addEvents(ul);
|
|
|
|
// Our range object is used in calculating menu positions
|
|
var Range = function(x1, x2, y1, y2) {
|
|
this.x1 = x1;
|
|
this.x2 = x2;
|
|
this.y1 = y1;
|
|
this.y2 = y2;
|
|
}
|
|
Range.prototype.contains = function(range) {
|
|
return (this.x1 <= range.x1 && range.x2 <= this.x2)
|
|
&&
|
|
(this.y1 <= range.y1 && range.y2 <= this.y2);
|
|
}
|
|
Range.prototype.transform = function(x, y) {
|
|
return new Range(this.x1 + x, this.x2 + x, this.y1 + y, this.y2 + y);
|
|
}
|
|
Range.prototype.nudgeX = function(range) {
|
|
if (this.x1 < range.x1) {
|
|
return new Range(range.x1, range.x1 + (this.x2 - this.x1), this.y1, this.y2);
|
|
} else if (this.x2 > range.x2) {
|
|
return new Range(range.x2 - (this.x2 - this.x1), range.x2, this.y1, this.y2);
|
|
}
|
|
return this;
|
|
}
|
|
Range.prototype.nudgeY = function(range) {
|
|
if (this.y1 < range.y1) {
|
|
return new Range(this.x1, this.x2, range.y1, range.y1 + (this.y2 - this.y1));
|
|
} else if (this.y2 > range.y2) {
|
|
return new Range(this.x1, this.x2, range.y2 - (this.y2 - this.y1), range.y2);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// window width & scroll offset
|
|
var sx = $(window).scrollLeft()
|
|
var sy = $(window).scrollTop();
|
|
var ww = $(window).innerWidth();
|
|
var wh = $(window).innerHeight();
|
|
|
|
var viewport = new Range( sx, sx + ww,
|
|
sy, sy + wh);
|
|
|
|
// "Show" our menu so we can calculate its width, set left and top so that it does not accidentally
|
|
// go offscreen and trigger browser scroll bars
|
|
$(ul).css({visibility: 'hidden', left: 0, top: 0}).show();
|
|
|
|
var menuWidth = $(ul).outerWidth();
|
|
var menuHeight = $(ul).outerHeight();
|
|
|
|
// Get the LI parent UL outerwidth in case borders are applied to it
|
|
var tp = $(this).parent();
|
|
var thisWidth = tp.outerWidth();
|
|
var thisBorderWidth = parseInt(tp.css('borderLeftWidth')) + parseInt(tp.css('borderRightWidth'));
|
|
//var thisBorderTop = parseInt(tp.css('borderTopWidth'));
|
|
var thisHeight = $(this).outerHeight();
|
|
var thisOffset = $(this).offset({border: false});
|
|
|
|
$(ul).hide().css({visibility: ''});
|
|
|
|
// We define a list of valid positions for our menu and then test against them to find one that works best
|
|
var position = [];
|
|
// Bottom Horizontal
|
|
// Menu is directly below and left edges aligned to parent item
|
|
position[0] = new Range(thisOffset.left, thisOffset.left + menuWidth,
|
|
thisOffset.top + thisHeight, thisOffset.top + thisHeight + menuHeight);
|
|
// Menu is directly below and right edges aligned to parent item
|
|
position[1] = new Range((thisOffset.left + thisWidth) - menuWidth, thisOffset.left + thisWidth,
|
|
position[0].y1, position[0].y2);
|
|
// Menu is "nudged" horizontally below parent item
|
|
position[2] = position[0].nudgeX(viewport);
|
|
|
|
// Right vertical
|
|
// Menu is directly right and top edge aligned to parent item
|
|
position[3] = new Range(thisOffset.left + thisWidth - thisBorderWidth, thisOffset.left + thisWidth - thisBorderWidth + menuWidth,
|
|
thisOffset.top, thisOffset.top + menuHeight);
|
|
// Menu is directly right and bottom edges aligned with parent item
|
|
position[4] = new Range(position[3].x1, position[3].x2,
|
|
position[0].y1 - menuHeight, position[0].y1);
|
|
// Menu is "nudged" vertically to right of parent item
|
|
position[5] = position[3].nudgeY(viewport);
|
|
|
|
// Top Horizontal
|
|
// Menu is directly top and left edges aligned to parent item
|
|
position[6] = new Range(thisOffset.left, thisOffset.left + menuWidth,
|
|
thisOffset.top - menuHeight, thisOffset.top);
|
|
// Menu is directly top and right edges aligned to parent item
|
|
position[7] = new Range((thisOffset.left + thisWidth) - menuWidth, thisOffset.left + thisWidth,
|
|
position[6].y1, position[6].y2);
|
|
// Menu is "nudged" horizontally to the top of parent item
|
|
position[8] = position[6].nudgeX(viewport);
|
|
|
|
// Left vertical
|
|
// Menu is directly left and top edges aligned to parent item
|
|
position[9] = new Range(thisOffset.left - menuWidth, thisOffset.left,
|
|
position[3].y1, position[3].y2);
|
|
// Menu is directly left and bottom edges aligned to parent item
|
|
position[10]= new Range(position[9].x1, position[9].x2,
|
|
position[4].y1 + thisHeight - menuHeight, position[4].y1 + thisHeight);
|
|
// Menu is "nudged" vertically to left of parent item
|
|
position[11]= position[10].nudgeY(viewport);
|
|
|
|
// This defines the order in which we test our positions
|
|
var order = [];
|
|
if ($(this).parent().is('.jd_menu_flag_root') && !settings.isVerticalMenu) {
|
|
order = [0, 1, 2, 6, 7, 8, 5, 11];
|
|
} else {
|
|
order = [3, 4, 5, 9, 10, 11, 0, 1, 2, 6, 7, 8];
|
|
}
|
|
|
|
// Set our default position (first position) if no others can be found
|
|
var pos = order[0];
|
|
for (var i = 0, j = order.length; i < j; i++) {
|
|
// If this position for our menu is within the viewport of the browser, use this position
|
|
if (viewport.contains(position[order[i]])) {
|
|
pos = order[i];
|
|
break;
|
|
}
|
|
}
|
|
var menuPosition = position[pos];
|
|
|
|
// Find if we are absolutely positioned or have an absolutely positioned parent
|
|
$(this).add($(this).parents()).each(function() {
|
|
if ($(this).css('position') == 'absolute') {
|
|
var abs = $(this).offset();
|
|
// Transform our coordinates to be relative to the absolute parent
|
|
menuPosition = menuPosition.transform(-abs.left, -abs.top);
|
|
return false;
|
|
}
|
|
});
|
|
|
|
switch (pos) {
|
|
case 3:
|
|
menuPosition.y1 += settings.offsetY;
|
|
case 4:
|
|
menuPosition.x1 -= settings.offsetX;
|
|
break;
|
|
|
|
case 9:
|
|
menuPosition.y1 += settings.offsetY;
|
|
case 10:
|
|
menuPosition.x1 += settings.offsetX;
|
|
break;
|
|
}
|
|
|
|
if (settings.iframe) {
|
|
$(ul).bgiframe();
|
|
}
|
|
|
|
if (settings.onAnimate) {
|
|
$(ul).css({left: menuPosition.x1, top: menuPosition.y1});
|
|
// The onAnimate method is expected to "show" the element it is passed
|
|
settings.onAnimate.apply(ul, [true]);
|
|
} else {
|
|
$(ul).css({left: menuPosition.x1, top: menuPosition.y1}).show();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// "this" is a reference to a UL menu to be hidden
|
|
function hideMenuUL(recurse) {
|
|
if (!$(this).is(':visible')) {
|
|
return false;
|
|
}
|
|
|
|
var settings = getSettings(this);
|
|
|
|
// Test if this menu should get hidden
|
|
if (settings.onHideCheck != null && settings.onHideCheck.apply(this) == false) {
|
|
return false;
|
|
}
|
|
|
|
// Hide all of our child menus first
|
|
$('> li ul:visible', this).each(function() {
|
|
hideMenuUL.apply(this, [false]);
|
|
});
|
|
|
|
// If we are the root, do not hide ourself
|
|
if ($(this).is('.jd_menu_flag_root')) {
|
|
alert('We are root');
|
|
return false;
|
|
}
|
|
|
|
var elms = $('> li', this).add($(this).parent());
|
|
elms.removeClass('jd_menu_hover').removeClass('jd_menu_hover_menubar')
|
|
.removeClass('jd_menu_active').removeClass('jd_menu_active_menubar')
|
|
.find('> a')
|
|
.removeClass('jd_menu_hover').removeClass('jd_menu_hover_menubar')
|
|
.removeClass('jd_menu_active').removeClass('jd_menu_active_menubar');
|
|
|
|
removeEvents(this);
|
|
$(this).each(function() {
|
|
if (settings.onAnimate != null) {
|
|
settings.onAnimate.apply(this, [false]);
|
|
} else {
|
|
$(this).hide();
|
|
}
|
|
}).find('> .bgiframe').remove();
|
|
// Our callback for after our menu is hidden
|
|
if (settings.onHide != null) {
|
|
settings.onHide.apply(this);
|
|
}
|
|
|
|
// Recursively hide our parent menus
|
|
if (recurse == true) {
|
|
$(this).parentsUntil('ul.jd_menu_flag_root')
|
|
.removeClass('jd_menu_hover').removeClass('jd_menu_hover_menubar')
|
|
.not('.jd_menu_flag_root').filter('ul')
|
|
.each(function() {
|
|
hideMenuUL.apply(this, [false]);
|
|
});
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Prevent the default (usually following a link)
|
|
function accessibleClick(e) {
|
|
if ($(this).is('.accessible')) {
|
|
// Stop the browser from the default link action allowing the
|
|
// click event to propagate to propagate to our LI (itemClick function)
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
|
|
// Trigger a menu click
|
|
function itemClick(e) {
|
|
e.stopPropagation();
|
|
|
|
var settings = getSettings(this);
|
|
if (settings.onClick != null && settings.onClick.apply(this) == false) {
|
|
return false;
|
|
}
|
|
|
|
if ($('> ul', this).size() > 0) {
|
|
showMenuLI.apply(this);
|
|
} else {
|
|
if (e.target == this) {
|
|
var link = $('> a', e.target).not('.accessible');
|
|
if (link.size() > 0) {
|
|
var a = link.get(0);
|
|
if (!a.onclick) {
|
|
window.open(a.href, a.target || '_self');
|
|
} else {
|
|
$(a).click();
|
|
}
|
|
}
|
|
}
|
|
|
|
hideMenuUL.apply($(this).parent(), [true]);
|
|
}
|
|
}
|
|
})(jQuery);
|