source: trunk/prototype/plugins/contextmenu/jquery.contextMenu.js @ 5497

Revision 5497, 53.7 KB checked in by adriano, 12 years ago (diff)

Ticket #2486 - alteracao dos menus de contexto e de ferramentas para a funcionalidade
Line 
1/*
2 * jQuery contextMenu - Plugin for simple contextMenu handling
3 *
4 * Version: 1.5.8
5 *
6 * Authors: Rodney Rehm, Addy Osmani (patches for FF)
7 * Web: http://medialize.github.com/jQuery-contextMenu/
8 *
9 * Licensed under
10 *   MIT License http://www.opensource.org/licenses/mit-license
11 *   GPL v3 http://opensource.org/licenses/GPL-3.0
12 *
13 */
14
15(function($, undefined){
16   
17    // TODO: -
18        // ARIA stuff: menuitem, menuitemcheckbox und menuitemradio
19        // create <menu> structure if $.support[htmlCommand || htmlMenuitem] and !opt.disableNative
20
21// determine html5 compatibility
22$.support.htmlMenuitem = ('HTMLMenuItemElement' in window);
23$.support.htmlCommand = ('HTMLCommandElement' in window);
24
25var // currently active contextMenu trigger
26    $currentTrigger = null,
27    // is contextMenu initialized with at least one menu?
28    initialized = false,
29    // flag stating to ignore the contextmenu event
30    ignoreThisClick = false,
31    // window handle
32    $win = $(window),
33    // number of registered menus
34    counter = 0,
35    // mapping selector to namespace
36    namespaces = {},
37    // mapping namespace to options
38    menus = {},
39    // custom command type handlers
40    types = {},
41    // default values
42    defaults = {
43        // selector of contextMenu trigger
44        selector: null,
45        // where to append the menu to
46        appendTo: null,
47        // method to trigger context menu ["right", "left", "hover"]
48        trigger: "right",
49        // hide menu when mouse leaves trigger / menu elements
50        autoHide: false,
51        // ignore right click triggers for left, hover or custom activation
52        ignoreRightClick: false,
53        // ms to wait before showing a hover-triggered context menu
54        delay: 200,
55        // determine position to show menu at
56        determinePosition: function($menu) {
57            // position to the lower middle of the trigger element
58            if ($.ui && $.ui.position) {
59                // .position() is provided as a jQuery UI utility
60                // (...and it won't work on hidden elements)
61                $menu.css('display', 'block').position({
62                    my: "center top",
63                    at: "center bottom",
64                    of: this,
65                    offset: "0 5",
66                    collision: "fit"
67                }).css('display', 'none');
68            } else {
69                // determine contextMenu position
70                var offset = this.offset();
71                offset.top += this.outerHeight();
72                offset.left += this.outerWidth() / 2 - $menu.outerWidth() / 2;
73                $menu.css(offset);
74            }
75        },
76        // position menu
77        position: function(opt, x, y) {
78            var $this = this,
79                offset;
80            // determine contextMenu position
81            if (!x && !y) {
82                opt.determinePosition.call(this, opt.$menu);
83                return;
84            } else if (x === "maintain" && y === "maintain") {
85                // x and y must not be changed (after re-show on command click)
86                offset = opt.$menu.position();
87            } else {
88                // x and y are given (by mouse event)
89                var triggerIsFixed = opt.$trigger.parents().andSelf()
90                    .filter(function() {
91                        return $(this).css('position') == "fixed";
92                    }).length;
93
94                if (triggerIsFixed) {
95                    y -= $win.scrollTop();
96                    x -= $win.scrollLeft();
97                }
98                offset = {top: y, left: x};
99            }
100           
101            // correct offset if viewport demands it
102            var bottom = $win.scrollTop() + $win.height(),
103                right = $win.scrollLeft() + $win.width(),
104                height = opt.$menu.height(),
105                width = opt.$menu.width();
106           
107            if (offset.top + height > bottom) {
108                offset.top -= height;
109            }
110           
111            if (offset.left + width > right) {
112                offset.left -= width;
113            }
114           
115            opt.$menu.css(offset);
116        },
117        // position the sub-menu
118        positionSubmenu: function($menu) {
119            if ($.ui && $.ui.position) {
120                // .position() is provided as a jQuery UI utility
121                // (...and it won't work on hidden elements)
122                $menu.css('display', 'block').position({
123                    my: "left top",
124                    at: "right top",
125                    of: this,
126                    collision: "fit"
127                }).css('display', '');
128            } else {
129                // determine contextMenu position
130                var offset = this.offset();
131                offset.top += 0;
132                offset.left += this.outerWidth();
133                $menu.css(offset);
134            }
135        },
136        // offset to add to zIndex
137        zIndex: 1,
138        // show hide animation settings
139        animation: {
140            duration: 50,
141            show: 'slideDown',
142            hide: 'slideUp'
143        },
144        // events
145        events: {
146            show: $.noop,
147            hide: $.noop
148        },
149        // default callback
150        callback: null,
151        // list of contextMenu items
152        items: {}
153    },
154    // mouse position for hover activation
155    hoveract = {
156        timer: null,
157        pageX: null,
158        pageY: null
159    },
160    // determine zIndex
161    zindex = function($t) {
162        var zin = 0,
163            $tt = $t;
164
165        while (true) {
166            zin = Math.max(zin, parseInt($tt.css('z-index'), 10) || 0);
167            $tt = $tt.parent();
168            if (!$tt || !$tt.length || $tt.prop('nodeName').toLowerCase() == 'body') {
169                break;
170            }
171        }
172       
173        return zin;
174    },
175    // event handlers
176    handle = {
177        // abort anything
178        abortevent: function(e){
179            e.preventDefault();
180            e.stopImmediatePropagation();
181        },
182       
183        // contextmenu show dispatcher
184        contextmenu: function(e) {
185            var $this = $(this);
186            // disable actual context-menu
187            e.preventDefault();
188            e.stopImmediatePropagation();
189           
190            // ignore right click trigger
191            if (ignoreThisClick) {
192                ignoreThisClick = false;
193                return;
194            }
195           
196            if (!$this.hasClass('context-menu-disabled')) {
197                // theoretically need to fire a show event at <menu>
198                // http://www.whatwg.org/specs/web-apps/current-work/multipage/interactive-elements.html#context-menus
199                // var evt = jQuery.Event("show", { data: data, pageX: e.pageX, pageY: e.pageY, relatedTarget: this });
200                // e.data.$menu.trigger(evt);
201               
202                $currentTrigger = $this;
203                if (e.data.build) {
204                    // dynamically build menu on invocation
205                    $.extend(true, e.data, defaults, e.data.build($currentTrigger, e) || {});
206                    op.create(e.data);
207                }
208                // show menu
209                op.show.call($this, e.data, e.pageX, e.pageY);
210            }
211        },
212        // contextMenu left-click trigger
213        click: function(e) {
214            e.preventDefault();
215            e.stopImmediatePropagation();
216            $(this).trigger(jQuery.Event("contextmenu", { data: e.data, pageX: e.pageX, pageY: e.pageY }));
217        },
218        // contextMenu right-click trigger
219        mousedown: function(e) {
220            // register mouse down
221            var $this = $(this);
222           
223            // hide any previous menus
224            if ($currentTrigger && $currentTrigger.length && !$currentTrigger.is($this)) {
225                $currentTrigger.data('contextMenu').$menu.trigger('contextmenu:hide');
226            }
227           
228            // activate on right click
229            if (e.button == 2) {
230                $currentTrigger = $this.data('contextMenuActive', true);
231            }
232        },
233        // contextMenu right-click trigger
234        mouseup: function(e) {
235            // show menu
236            var $this = $(this);
237            if ($this.data('contextMenuActive') && $currentTrigger && $currentTrigger.length && $currentTrigger.is($this) && !$this.hasClass('context-menu-disabled')) {
238                e.preventDefault();
239                e.stopImmediatePropagation();
240                $currentTrigger = $this;
241                $this.trigger(jQuery.Event("contextmenu", { data: e.data, pageX: e.pageX, pageY: e.pageY }));
242            }
243           
244            $this.removeData('contextMenuActive');
245        },
246        // contextMenu hover trigger
247        mouseenter: function(e) {
248            var $this = $(this),
249                $related = $(e.relatedTarget),
250                $document = $(document);
251           
252            // abort if we're coming from a menu
253            if ($related.is('.context-menu-list') || $related.closest('.context-menu-list').length) {
254                return;
255            }
256           
257            // abort if a menu is shown
258            if ($currentTrigger && $currentTrigger.length) {
259                return;
260            }
261           
262            hoveract.pageX = e.pageX;
263            hoveract.pageY = e.pageY;
264            hoveract.data = e.data;
265            $document.on('mousemove.contextMenuShow', handle.mousemove);
266            hoveract.timer = setTimeout(function() {
267                hoveract.timer = null;
268                $document.off('mousemove.contextMenuShow');
269                $currentTrigger = $this;
270                $this.trigger(jQuery.Event("contextmenu", { data: hoveract.data, pageX: hoveract.pageX, pageY: hoveract.pageY }));
271            }, e.data.delay );
272        },
273        // contextMenu hover trigger
274        mousemove: function(e) {
275            hoveract.pageX = e.pageX;
276            hoveract.pageY = e.pageY;
277        },
278        // contextMenu hover trigger
279        mouseleave: function(e) {
280            // abort if we're leaving for a menu
281            var $related = $(e.relatedTarget);
282            if ($related.is('.context-menu-list') || $related.closest('.context-menu-list').length) {
283                return;
284            }
285           
286            try {
287                clearTimeout(hoveract.timer);
288            } catch(e) {}
289           
290            hoveract.timer = null;
291        },
292
293        // ignore right click trigger
294        ignoreRightClick: function(e) {
295            if (e.button == 2) {
296                ignoreThisClick = true;
297            }
298        },
299       
300        // click on layer to hide contextMenu
301        layerClick: function(e) {
302            var $this = $(this),
303                root = $this.data('contextMenuRoot');
304               
305            e.preventDefault();
306            e.stopImmediatePropagation();
307            $this.remove();
308            root.$menu.trigger('contextmenu:hide');
309        },
310        // key handled :hover
311        keyStop: function(e, opt) {
312            if (!opt.isInput) {
313                e.preventDefault();
314            }
315           
316            e.stopPropagation();
317        },
318        key: function(e) {
319            var opt = $currentTrigger.data('contextMenu') || {},
320                $children = opt.$menu.children(),
321                $round;
322
323            switch (e.keyCode) {
324                case 9:
325                case 38: // up
326                    handle.keyStop(e, opt);
327                    // if keyCode is [38 (up)] or [9 (tab) with shift]
328                    if (opt.isInput) {
329                        if (e.keyCode == 9 && e.shiftKey) {
330                            e.preventDefault();
331                            opt.$selected && opt.$selected.find('input, textarea, select').blur();
332                            opt.$menu.trigger('prevcommand');
333                            return;
334                        } else if (e.keyCode == 38 && opt.$selected.find('input, textarea, select').prop('type') == 'checkbox') {
335                            // checkboxes don't capture this key
336                            e.preventDefault();
337                            return;
338                        }
339                    } else if (e.keyCode != 9 || e.shiftKey) {
340                        opt.$menu.trigger('prevcommand');
341                        return;
342                    }
343                   
344                case 9: // tab
345                case 40: // down
346                    handle.keyStop(e, opt);
347                    if (opt.isInput) {
348                        if (e.keyCode == 9) {
349                            e.preventDefault();
350                            opt.$selected && opt.$selected.find('input, textarea, select').blur();
351                            opt.$menu.trigger('nextcommand');
352                            return;
353                        } else if (e.keyCode == 40 && opt.$selected.find('input, textarea, select').prop('type') == 'checkbox') {
354                            // checkboxes don't capture this key
355                            e.preventDefault();
356                            return;
357                        }
358                    } else {
359                        opt.$menu.trigger('nextcommand');
360                        return;
361                    }
362                    break;
363               
364                case 37: // left
365                    handle.keyStop(e, opt);
366                    if (opt.isInput || !opt.$selected || !opt.$selected.length) {
367                        break;
368                    }
369               
370                    if (!opt.$selected.parent().hasClass('context-menu-root')) {
371                        var $parent = opt.$selected.parent().parent();
372                        opt.$selected.trigger('contextmenu:blur');
373                        opt.$selected = $parent;
374                        return;
375                    }
376                    break;
377                   
378                case 39: // right
379                    handle.keyStop(e, opt);
380                    if (opt.isInput || !opt.$selected || !opt.$selected.length) {
381                        break;
382                    }
383                   
384                    var itemdata = opt.$selected.data('contextMenu') || {};
385                    if (itemdata.$menu && opt.$selected.hasClass('context-menu-submenu')) {
386                        opt.$selected = null;
387                        itemdata.$selected = null;
388                        itemdata.$menu.trigger('nextcommand');
389                        return;
390                    }
391                    break;
392               
393                case 35: // end
394                case 36: // home
395                    if (opt.$selected && opt.$selected.find('input, textarea, select').length) {
396                        return;
397                    } else {
398                        (opt.$selected && opt.$selected.parent() || opt.$menu)
399                            .children(':not(.disabled, .not-selectable)')[e.keyCode == 36 ? 'first' : 'last']()
400                            .trigger('contextmenu:focus');
401                        e.preventDefault();
402                        return;
403                    }
404                    break;
405                   
406                case 13: // enter
407                    handle.keyStop(e, opt);
408                    if (opt.isInput) {
409                        if (opt.$selected && !opt.$selected.is('textarea, select')) {
410                            e.preventDefault();
411                            return;
412                        }
413                        break;
414                    }
415                    opt.$selected && opt.$selected.trigger('mouseup');
416                    return;
417                   
418                case 32: // space
419                case 33: // page up
420                case 34: // page down
421                    // prevent browser from scrolling down while menu is visible
422                    handle.keyStop(e, opt);
423                    return;
424                   
425                case 27: // esc
426                    handle.keyStop(e, opt);
427                    opt.$menu.trigger('contextmenu:hide');
428                    return;
429                   
430                default: // 0-9, a-z
431                    var k = (String.fromCharCode(e.keyCode)).toUpperCase();
432                    if (opt.accesskeys[k]) {
433                        // according to the specs accesskeys must be invoked immediately
434                        opt.accesskeys[k].$node.trigger(opt.accesskeys[k].$menu
435                            ? 'contextmenu:focus'
436                            : 'mouseup'
437                        );
438                        return;
439                    }
440                    break;
441            }
442            // pass event to selected item,
443            // stop propagation to avoid endless recursion
444            e.stopPropagation();
445            opt.$selected && opt.$selected.trigger(e);
446        },
447
448        // select previous possible command in menu
449        prevItem: function(e) {
450            e.stopPropagation();
451            var opt = $(this).data('contextMenu') || {};
452
453            // obtain currently selected menu
454            if (opt.$selected) {
455                var $s = opt.$selected;
456                opt = opt.$selected.parent().data('contextMenu') || {};
457                opt.$selected = $s;
458            }
459           
460            var $children = opt.$menu.children(),
461                $prev = !opt.$selected || !opt.$selected.prev().length ? $children.last() : opt.$selected.prev(),
462                $round = $prev;
463           
464            // skip disabled
465            while ($prev.hasClass('disabled') || $prev.hasClass('not-selectable')) {
466                if ($prev.prev().length) {
467                    $prev = $prev.prev();
468                } else {
469                    $prev = $children.last();
470                }
471                if ($prev.is($round)) {
472                    // break endless loop
473                    return;
474                }
475            }
476           
477            // leave current
478            if (opt.$selected) {
479                handle.itemMouseleave.call(opt.$selected.get(0), e);
480            }
481           
482            // activate next
483            handle.itemMouseenter.call($prev.get(0), e);
484           
485            // focus input
486            var $input = $prev.find('input, textarea, select');
487            if ($input.length) {
488                $input.focus();
489            }
490        },
491        // select next possible command in menu
492        nextItem: function(e) {
493            e.stopPropagation();
494            var opt = $(this).data('contextMenu') || {};
495
496            // obtain currently selected menu
497            if (opt.$selected) {
498                var $s = opt.$selected;
499                opt = opt.$selected.parent().data('contextMenu') || {};
500                opt.$selected = $s;
501            }
502
503            var $children = opt.$menu.children(),
504                $next = !opt.$selected || !opt.$selected.next().length ? $children.first() : opt.$selected.next(),
505                $round = $next;
506
507            // skip disabled
508            while ($next.hasClass('disabled') || $next.hasClass('not-selectable')) {
509                if ($next.next().length) {
510                    $next = $next.next();
511                } else {
512                    $next = $children.first();
513                }
514                if ($next.is($round)) {
515                    // break endless loop
516                    return;
517                }
518            }
519           
520            // leave current
521            if (opt.$selected) {
522                handle.itemMouseleave.call(opt.$selected.get(0), e);
523            }
524           
525            // activate next
526            handle.itemMouseenter.call($next.get(0), e);
527           
528            // focus input
529            var $input = $next.find('input, textarea, select');
530            if ($input.length) {
531                $input.focus();
532            }
533        },
534       
535        // flag that we're inside an input so the key handler can act accordingly
536        focusInput: function(e) {
537            var $this = $(this).closest('.context-menu-item'),
538                data = $this.data(),
539                opt = data.contextMenu,
540                root = data.contextMenuRoot;
541
542            root.$selected = opt.$selected = $this;
543            root.isInput = opt.isInput = true;
544        },
545        // flag that we're inside an input so the key handler can act accordingly
546        blurInput: function(e) {
547            var $this = $(this).closest('.context-menu-item'),
548                data = $this.data(),
549                opt = data.contextMenu,
550                root = data.contextMenuRoot;
551
552            root.isInput = opt.isInput = false;
553        },
554       
555        // :hover on menu
556        menuMouseenter: function(e) {
557            var root = $(this).data().contextMenuRoot;
558            root.hovering = true;
559        },
560        // :hover on menu
561        menuMouseleave: function(e) {
562            var root = $(this).data().contextMenuRoot;
563            if (root.$layer && root.$layer.is(e.relatedTarget)) {
564                root.hovering = false;
565            }
566        },
567       
568       
569        // :hover done manually so key handling is possible
570        itemMouseenter: function(e) {
571            var $this = $(this),
572                data = $this.data(),
573                opt = data.contextMenu,
574                root = data.contextMenuRoot;
575           
576            root.hovering = true;
577
578            // abort if we're re-entering
579            if (e && root.$layer && root.$layer.is(e.relatedTarget)) {
580                e.preventDefault();
581                e.stopImmediatePropagation();
582            }
583
584            // make sure only one item is selected
585            (opt.$menu ? opt : root).$menu
586                .children('.hover').trigger('contextmenu:blur');
587
588            if ($this.hasClass('disabled') || $this.hasClass('not-selectable')) {
589                opt.$selected = null;
590                return;
591            }
592           
593            $this.trigger('contextmenu:focus');
594        },
595        // :hover done manually so key handling is possible
596        itemMouseleave: function(e) {
597            var $this = $(this),
598                data = $this.data(),
599                opt = data.contextMenu,
600                root = data.contextMenuRoot;
601
602            if (root !== opt && root.$layer && root.$layer.is(e.relatedTarget)) {
603                root.$selected && root.$selected.trigger('contextmenu:blur');
604                e.preventDefault();
605                e.stopImmediatePropagation();
606                root.$selected = opt.$selected = opt.$node;
607                return;
608            }
609           
610            $this.trigger('contextmenu:blur');
611        },
612        // contextMenu item click
613        itemClick: function(e) {
614            var $this = $(this),
615                data = $this.data(),
616                opt = data.contextMenu,
617                root = data.contextMenuRoot,
618                key = data.contextMenuKey,
619                callback;
620
621            // abort if the key is unknown or disabled
622            if (!opt.items[key] || $this.hasClass('disabled')) {
623                return;
624            }
625
626            e.preventDefault();
627            e.stopImmediatePropagation();
628
629            if ($.isFunction(root.callbacks[key])) {
630                // item-specific callback
631                callback = root.callbacks[key];
632            } else if ($.isFunction(root.callback)) {
633                // default callback
634                callback = root.callback;               
635            } else {
636                // no callback, no action
637                return;
638            }
639
640            // hide menu if callback doesn't stop that
641            if (callback.call(root.$trigger, key, root) !== false) {
642                root.$menu.trigger('contextmenu:hide');
643            } else {
644                op.update.call(root.$trigger, root);
645            }
646        },
647        // ignore click events on input elements
648        inputClick: function(e) {
649            e.stopImmediatePropagation();
650        },
651       
652        // hide <menu>
653        hideMenu: function(e) {
654            var root = $(this).data('contextMenuRoot');
655            op.hide.call(root.$trigger, root);
656        },
657        // focus <command>
658        focusItem: function(e) {
659            e.stopPropagation();
660            var $this = $(this),
661                data = $this.data(),
662                opt = data.contextMenu,
663                root = data.contextMenuRoot;
664
665            $this.addClass('hover')
666                .siblings('.hover').trigger('contextmenu:blur');
667           
668            // remember selected
669            opt.$selected = root.$selected = $this;
670           
671            // position sub-menu - do after show so dumb $.ui.position can keep up
672            if (opt.$node) {
673                root.positionSubmenu.call(opt.$node, opt.$menu);
674            }
675        },
676        // blur <command>
677        blurItem: function(e) {
678            e.stopPropagation();
679            var $this = $(this),
680                data = $this.data(),
681                opt = data.contextMenu,
682                root = data.contextMenuRoot;
683           
684            $this.removeClass('hover');
685            opt.$selected = null;
686        }
687    },
688    // operations
689    op = {
690        show: function(opt, x, y) {
691            var $this = $(this),
692                offset,
693                css = {};
694
695            // hide any open menus
696            $('#context-menu-layer').trigger('mousedown');
697
698            // show event
699            if (opt.events.show.call($this, opt) === false) {
700                $currentTrigger = null;
701                return;
702            }
703           
704            // backreference for callbacks
705            opt.$trigger = $this;
706
707            // create or update context menu
708            op.update.call($this, opt);
709           
710            // position menu
711            opt.position.call($this, opt, x, y);
712
713            // make sure we're in front
714            if (opt.zIndex) {
715                css.zIndex = zindex($this) + opt.zIndex;
716            }
717           
718            // add layer
719            op.layer.call(opt.$menu, opt, css.zIndex);
720           
721            // adjust sub-menu zIndexes
722            opt.$menu.find('ul').css('zIndex', css.zIndex + 1);
723           
724            // position and show context menu
725            opt.$menu.css( css )[opt.animation.show](opt.animation.duration);
726            // make options available
727            $this.data('contextMenu', opt);
728            // register key handler
729            $(document).off('keydown.contextMenu').on('keydown.contextMenu', handle.key);
730            // register autoHide handler
731            if (opt.autoHide) {
732                // trigger element coordinates
733                var pos = $this.position();
734                pos.right = pos.left + $this.outerWidth();
735                pos.bottom = pos.top + this.outerHeight();
736                // mouse position handler
737                $(document).on('mousemove.contextMenuAutoHide', function(e) {
738                    if (opt.$layer && !opt.hovering && (!(e.pageX >= pos.left && e.pageX <= pos.right) || !(e.pageY >= pos.top && e.pageY <= pos.bottom))) {
739                        // if mouse in menu...
740                        opt.$layer.trigger('mousedown');
741                    }
742                });
743            }
744        },
745        hide: function(opt) {
746            var $this = $(this);
747            if (!opt) {
748                opt = $this.data('contextMenu') || {};
749            }
750           
751            // hide event
752            if (opt.events && opt.events.hide.call($this, opt) === false) {
753                return;
754            }
755           
756            if (opt.$layer) {
757                try {
758                    opt.$layer.remove();
759                    delete opt.$layer;
760                } catch(e) {
761                    opt.$layer = null;
762                }
763            }
764           
765            // remove handle
766            $currentTrigger = null;
767            // remove selected
768            opt.$menu.find('.hover').trigger('contextmenu:blur');
769            opt.$selected = null;
770            // unregister key and mouse handlers
771            //$(document).off('.contextMenuAutoHide keydown.contextMenu'); // http://bugs.jquery.com/ticket/10705
772            $(document).off('.contextMenuAutoHide').off('keydown.contextMenu');
773            // hide menu
774            opt.$menu && opt.$menu[opt.animation.hide](opt.animation.duration);
775           
776            // tear down dynamically built menu
777            if (opt.build) {
778                opt.$menu.remove();
779                $.each(opt, function(key, value) {
780                    switch (key) {
781                        case 'ns':
782                        case 'selector':
783                        case 'build':
784                        case 'trigger':
785                        case 'ignoreRightClick':
786                            return true;
787
788                        default:
789                            opt[key] = undefined;
790                            try {
791                                delete opt[key];
792                            } catch (e) {}
793                            return true;
794                   }
795                });
796            }
797        },
798        create: function(opt, root) {
799            if (root === undefined) {
800                root = opt;
801            }
802            // create contextMenu
803            opt.$menu = $('<ul class="context-menu-list ' + (opt.className || "") + '"></ul>').data({
804                'contextMenu': opt,
805                'contextMenuRoot': root
806            });
807           
808            $.each(['callbacks', 'commands', 'inputs'], function(i,k){
809                opt[k] = {};
810                if (!root[k]) {
811                    root[k] = {};
812                }
813            });
814           
815            root.accesskeys || (root.accesskeys = {});
816           
817            // create contextMenu items
818            $.each(opt.items, function(key, item){
819                var $t = $('<li class="context-menu-item ' + (item.className || "") +'"></li>'),
820                    $label = null,
821                    $input = null;
822               
823                item.$node = $t.data({
824                    'contextMenu': opt,
825                    'contextMenuRoot': root,
826                    'contextMenuKey': key
827                });
828               
829                // register accesskey
830                // NOTE: the accesskey attribute should be applicable to any element, but Safari5 and Chrome13 still can't do that
831                if (item.accesskey) {
832                    var aks = splitAccesskey(item.accesskey);
833                    for (var i=0, ak; ak = aks[i]; i++) {
834                        if (!root.accesskeys[ak]) {
835                            root.accesskeys[ak] = item;
836                            item._name = item.name.replace(new RegExp('(' + ak + ')', 'i'), '<span class="context-menu-accesskey">$1</span>');
837                            break;
838                        }
839                    }
840                }
841               
842                if (typeof item == "string") {
843                    $t.addClass('context-menu-separator not-selectable');
844                } else if (item.type && types[item.type]) {
845                    // run custom type handler
846                    types[item.type].call($t, item, opt, root);
847                    // register commands
848                    $.each([opt, root], function(i,k){
849                        k.commands[key] = item;
850                        if ($.isFunction(item.callback)) {
851                            k.callbacks[key] = item.callback;
852                        }
853                    });
854                } else {
855                    // add label for input
856                    if (item.type == 'html') {
857                        $t.addClass('context-menu-html not-selectable');
858                    } else if (item.type) {
859                        $label = $('<label></label>').appendTo($t);
860                        $('<span></span>').html(item._name || item.name).appendTo($label);
861                        $t.addClass('context-menu-input');
862                        opt.hasTypes = true;
863                        $.each([opt, root], function(i,k){
864                            k.commands[key] = item;
865                            k.inputs[key] = item;
866                        });
867                    } else if (item.items) {
868                        item.type = 'sub';
869                    }
870               
871                    switch (item.type) {
872                        case 'text':
873                            $input = $('<input type="text" value="1" name="context-menu-input-'+ key +'" value="">')
874                                .val(item.value || "").appendTo($label);
875                            break;
876                   
877                        case 'textarea':
878                            $input = $('<textarea name="context-menu-input-'+ key +'"></textarea>')
879                                .val(item.value || "").appendTo($label);
880
881                            if (item.height) {
882                                $input.height(item.height);
883                            }
884                            break;
885
886                        case 'checkbox':
887                            $input = $('<input type="checkbox" value="1" name="context-menu-input-'+ key +'" value="">')
888                                .val(item.value || "").prop("checked", !!item.selected).prependTo($label);
889                            break;
890
891                        case 'radio':
892                            $input = $('<input type="radio" value="1" name="context-menu-input-'+ item.radio +'" value="">')
893                                .val(item.value || "").prop("checked", !!item.selected).prependTo($label);
894                            break;
895                   
896                        case 'select':
897                            $input = $('<select name="context-menu-input-'+ key +'">').appendTo($label);
898                            if (item.options) {
899                                $.each(item.options, function(value, text) {
900                                    $('<option></option>').val(value).text(text).appendTo($input);
901                                });
902                                $input.val(item.selected);
903                            }
904                            break;
905                       
906                        case 'sub':
907                            $('<span></span>').html(item._name || item.name).appendTo($t);
908                            item.appendTo = item.$node;
909                            op.create(item, root);
910                            $t.data('contextMenu', item).addClass('context-menu-submenu');
911                            item.callback = null;
912                            break;
913                       
914                        case 'html':
915                            $(item.html).appendTo($t);
916                            break;
917                       
918                        default:
919                            $.each([opt, root], function(i,k){
920                                k.commands[key] = item;
921                                if ($.isFunction(item.callback)) {
922                                    k.callbacks[key] = item.callback;
923                                }
924                            });
925                           
926                            $('<span></span>').html(item._name || item.name || "").appendTo($t);
927                            break;
928                    }
929                   
930                    // disable key listener in <input>
931                    if (item.type && item.type != 'sub' && item.type != 'html') {
932                        $input
933                            .on('focus', handle.focusInput)
934                            .on('blur', handle.blurInput);
935                       
936                        if (item.events) {
937                            $input.on(item.events);
938                        }
939                    }
940               
941                    // add icons
942                    if (item.icon) {
943                        $t.addClass("icon icon-" + item.icon);
944                    }
945                }
946               
947                // cache contained elements
948                item.$input = $input;
949                item.$label = $label;
950
951                // attach item to menu
952                $t.appendTo(opt.$menu);
953               
954                // Disable text selection
955                if (!opt.hasTypes) {
956                    if($.browser.msie) {
957                        $t.on('selectstart.disableTextSelect', handle.abortevent);
958                    } else if(!$.browser.mozilla) {
959                        $t.on('mousedown.disableTextSelect', handle.abortevent);
960                    }
961                }
962            });
963            // attach contextMenu to <body> (to bypass any possible overflow:hidden issues on parents of the trigger element)
964            if (!opt.$node) {
965                opt.$menu.css('display', 'none').addClass('context-menu-root');
966            }
967            opt.$menu.appendTo(opt.appendTo || document.body);
968        },
969        update: function(opt, root) {
970            var $this = this;
971            if (root === undefined) {
972                root = opt;
973                // determine widths of submenus, as CSS won't grow them automatically
974                // position:absolute > position:absolute; min-width:100; max-width:200; results in width: 100;
975                // kinda sucks hard...
976                opt.$menu.find('ul').andSelf().css({position: 'static', display: 'block'}).each(function(){
977                    var $this = $(this);
978                    $this.width($this.css('position', 'absolute').width())
979                        .css('position', 'static');
980                }).css({position: '', display: ''});
981            }
982            // re-check disabled for each item
983            opt.$menu.children().each(function(){
984                var $item = $(this),
985                    key = $item.data('contextMenuKey'),
986                    item = opt.items[key],
987                    disabled = ($.isFunction(item.disabled) && item.disabled.call($this, key, root)) || item.disabled === true;
988
989                // dis- / enable item
990                $item[disabled ? 'addClass' : 'removeClass']('disabled');
991               
992                if (item.type) {
993                    // dis- / enable input elements
994                    $item.find('input, select, textarea').prop('disabled', disabled);
995                   
996                    // update input states
997                    switch (item.type) {
998                        case 'text':
999                        case 'textarea':
1000                            item.$input.val(item.value || "");
1001                            break;
1002                           
1003                        case 'checkbox':
1004                        case 'radio':
1005                            item.$input.val(item.value || "").prop('checked', !!item.selected);
1006                            break;
1007                           
1008                        case 'select':
1009                            item.$input.val(item.selected || "");
1010                            break;
1011                    }
1012                }
1013               
1014                if (item.$menu) {
1015                    // update sub-menu
1016                    op.update.call($this, item, root);
1017                }
1018            });
1019        },
1020        layer: function(opt, zIndex) {
1021            // add transparent layer for click area
1022            // filter and background for Internet Explorer, Issue #23
1023            return opt.$layer = $('<div id="context-menu-layer" style="position:fixed; z-index:' + zIndex + '; top:0; left:0; opacity: 0; filter: alpha(opacity=0); background-color: #000;"></div>')
1024                .css({height: $win.height(), width: $win.width(), display: 'block'})
1025                .data('contextMenuRoot', opt)
1026                .insertBefore(this)
1027                .on('mousedown', handle.layerClick);
1028        }
1029    };
1030
1031// split accesskey according to http://www.whatwg.org/specs/web-apps/current-work/multipage/editing.html#assigned-access-key
1032function splitAccesskey(val) {
1033    var t = val.split(/\s+/),
1034        keys = [];
1035       
1036    for (var i=0, k; k = t[i]; i++) {
1037        k = k[0].toUpperCase(); // first character only
1038        // theoretically non-accessible characters should be ignored, but different systems, different keyboard layouts, ... screw it.
1039        // a map to look up already used access keys would be nice
1040        keys.push(k);
1041    }
1042   
1043    return keys;
1044}
1045
1046// handle contextMenu triggers
1047$.fn.contextMenu = function(operation) {
1048    if (operation === undefined) {
1049        this.first().trigger('contextmenu');
1050    } else if (operation.x && operation.y) {
1051        this.first().trigger(jQuery.Event("contextmenu", {pageX: operation.x, pageY: operation.y}));
1052    } else if (operation === "hide") {
1053        var $menu = this.data('contextMenu').$menu;
1054        $menu && $menu.trigger('contextmenu:hide');
1055    } else if (operation) {
1056        this.removeClass('context-menu-disabled');
1057    } else if (!operation) {
1058        this.addClass('context-menu-disabled');
1059    }
1060   
1061    return this;
1062};
1063
1064// manage contextMenu instances
1065$.contextMenu = function(operation, options) {
1066    if (typeof operation != 'string') {
1067        options = operation;
1068        operation = 'create';
1069    }
1070   
1071    if (typeof options == 'string') {
1072        options = {selector: options};
1073    } else if (options === undefined) {
1074        options = {};
1075    }
1076   
1077    // merge with default options
1078    var o = $.extend(true, {}, defaults, options || {}),
1079        $body = $body = $(document);
1080   
1081    switch (operation) {
1082        case 'create':
1083            // no selector no joy
1084            if (!o.selector) {
1085                throw new Error('No selector specified');
1086            }
1087            // make sure internal classes are not bound to
1088            if (o.selector.match(/.context-menu-(list|item|input)($|\s)/)) {
1089                throw new Error('Cannot bind to selector "' + o.selector + '" as it contains a reserved className');
1090            }
1091            if (!o.build && (!o.items || $.isEmptyObject(o.items))) {
1092                throw new Error('No Items sepcified');
1093            }
1094            counter ++;
1095            o.ns = '.contextMenu' + counter;
1096            namespaces[o.selector] = o.ns;
1097            menus[o.ns] = o;
1098           
1099            if (!initialized) {
1100                // make sure item click is registered first
1101                $body
1102                    .on({
1103                        'contextmenu:hide.contextMenu': handle.hideMenu,
1104                        'prevcommand.contextMenu': handle.prevItem,
1105                        'nextcommand.contextMenu': handle.nextItem,
1106                        'contextmenu.contextMenu': handle.abortevent,
1107                        'mouseenter.contextMenu': handle.menuMouseenter,
1108                        'mouseleave.contextMenu': handle.menuMouseleave
1109                    }, '.context-menu-list')
1110                    .on('mouseup.contextMenu', '.context-menu-input', handle.inputClick)
1111                    .on({
1112                        'mouseup.contextMenu': handle.itemClick,
1113                        'contextmenu:focus.contextMenu': handle.focusItem,
1114                        'contextmenu:blur.contextMenu': handle.blurItem,
1115                        'contextmenu.contextMenu': handle.abortevent,
1116                        'mouseenter.contextMenu': handle.itemMouseenter,
1117                        'mouseleave.contextMenu': handle.itemMouseleave
1118                    }, '.context-menu-item');
1119
1120                initialized = true;
1121            }
1122           
1123            // engage native contextmenu event
1124            $body
1125                .on('contextmenu' + o.ns, o.selector, o, handle.contextmenu);
1126           
1127            switch (o.trigger) {
1128                case 'hover':
1129                        $body
1130                            .on('mouseenter' + o.ns, o.selector, o, handle.mouseenter)
1131                            .on('mouseleave' + o.ns, o.selector, o, handle.mouseleave);                   
1132                    break;
1133                   
1134                case 'left':
1135                        $body.on('click' + o.ns, o.selector, o, handle.click);
1136                    break;
1137                /*
1138                default:
1139                    // http://www.quirksmode.org/dom/events/contextmenu.html
1140                    $body
1141                        .on('mousedown' + o.ns, o.selector, o, handle.mousedown)
1142                        .on('mouseup' + o.ns, o.selector, o, handle.mouseup);
1143                    break;
1144                */
1145            }
1146           
1147            if (o.trigger != 'hover' && o.ignoreRightClick) {
1148                $body.on('mousedown' + o.ns, o.selector, handle.ignoreRightClick);
1149            }
1150
1151            // create menu
1152            if (!o.build) {
1153                op.create(o);
1154            }
1155            break;
1156       
1157        case 'destroy':
1158            if (!o.selector) {
1159                $body.off('.contextMenu .contextMenuAutoHide');
1160                $.each(namespaces, function(key, value) {
1161                    $body.off(value);
1162                });
1163               
1164                namespaces = {};
1165                menus = {};
1166                counter = 0;
1167                initialized = false;
1168               
1169                $('.context-menu-list').remove();
1170            } else if (namespaces[o.selector]) {
1171                try {
1172                    if (menus[namespaces[o.selector]].$menu) {
1173                        menus[namespaces[o.selector]].$menu.remove();
1174                    }
1175                   
1176                    delete menus[namespaces[o.selector]];
1177                } catch(e) {
1178                    menus[namespaces[o.selector]] = null;
1179                }
1180               
1181                $body.off(namespaces[o.selector]);
1182            }
1183            break;
1184       
1185        case 'html5':
1186            // if <command> or <menuitem> are not handled by the browser,
1187            // or options was a bool true,
1188            // initialize $.contextMenu for them
1189            if ((!$.support.htmlCommand && !$.support.htmlMenuitem) || (typeof options == "boolean" && options)) {
1190                $('menu[type="context"]').each(function() {
1191                    if (this.id) {
1192                        $.contextMenu({
1193                            selector: '[contextmenu=' + this.id +']',
1194                            items: $.contextMenu.fromMenu(this)
1195                        });
1196                    }
1197                }).css('display', 'none');
1198            }
1199            break;
1200       
1201        default:
1202            throw new Error('Unknown operation "' + operation + '"');
1203    }
1204   
1205    return this;
1206};
1207
1208// import values into <input> commands
1209$.contextMenu.setInputValues = function(opt, data) {
1210    if (data === undefined) {
1211        data = {};
1212    }
1213   
1214    $.each(opt.inputs, function(key, item) {
1215        switch (item.type) {
1216            case 'text':
1217            case 'textarea':
1218                item.value = data[key] || "";
1219                break;
1220
1221            case 'checkbox':
1222                item.selected = data[key] ? true : false;
1223                break;
1224               
1225            case 'radio':
1226                item.selected = (data[item.radio] || "") == item.value ? true : false;
1227                break;
1228           
1229            case 'select':
1230                item.selected = data[key] || "";
1231                break;
1232        }
1233    });
1234};
1235
1236// export values from <input> commands
1237$.contextMenu.getInputValues = function(opt, data) {
1238    if (data === undefined) {
1239        data = {};
1240    }
1241   
1242    $.each(opt.inputs, function(key, item) {
1243        switch (item.type) {
1244            case 'text':
1245            case 'textarea':
1246            case 'select':
1247                data[key] = item.$input.val();
1248                break;
1249
1250            case 'checkbox':
1251                data[key] = item.$input.prop('checked');
1252                break;
1253               
1254            case 'radio':
1255                if (item.$input.prop('checked')) {
1256                    data[item.radio] = item.value;
1257                }
1258                break;
1259        }
1260    });
1261   
1262    return data;
1263};
1264
1265// find <label for="xyz">
1266function inputLabel(node) {
1267    return (node.id && $('label[for="'+ node.id +'"]').val()) || node.name;
1268}
1269
1270// convert <menu> to items object
1271function menuChildren(items, $children, counter) {
1272    if (!counter) {
1273        counter = 0;
1274    }
1275   
1276    $children.each(function() {
1277        var $node = $(this),
1278            node = this,
1279            nodeName = this.nodeName.toLowerCase(),
1280            label,
1281            item;
1282       
1283        // extract <label><input>
1284        if (nodeName == 'label' && $node.find('input, textarea, select').length) {
1285            label = $node.text();
1286            $node = $node.children().first();
1287            node = $node.get(0);
1288            nodeName = node.nodeName.toLowerCase();
1289        }
1290       
1291        /*
1292         * <menu> accepts flow-content as children. that means <embed>, <canvas> and such are valid menu items.
1293         * Not being the sadistic kind, $.contextMenu only accepts:
1294         * <command>, <menuitem>, <hr>, <span>, <p> <input [text, radio, checkbox]>, <textarea>, <select> and of course <menu>.
1295         * Everything else will be imported as an html node, which is not interfaced with contextMenu.
1296         */
1297       
1298        // http://www.whatwg.org/specs/web-apps/current-work/multipage/commands.html#concept-command
1299        switch (nodeName) {
1300            // http://www.whatwg.org/specs/web-apps/current-work/multipage/interactive-elements.html#the-menu-element
1301            case 'menu':
1302                item = {name: $node.attr('label'), items: {}};
1303                menuChildren(item.items, $node.children(), counter);
1304                break;
1305           
1306            // http://www.whatwg.org/specs/web-apps/current-work/multipage/commands.html#using-the-a-element-to-define-a-command
1307            case 'a':
1308            // http://www.whatwg.org/specs/web-apps/current-work/multipage/commands.html#using-the-button-element-to-define-a-command
1309            case 'button':
1310                item = {
1311                    name: $node.text(),
1312                    disabled: !!$node.attr('disabled'),
1313                    callback: (function(){ return function(){ $node.click(); }; })()
1314                };
1315                break;
1316           
1317            // http://www.whatwg.org/specs/web-apps/current-work/multipage/commands.html#using-the-command-element-to-define-a-command
1318
1319            case 'menuitem':
1320            case 'command':
1321                switch ($node.attr('type')) {
1322                    case undefined:
1323                    case 'command':
1324                    case 'menuitem':
1325                        item = {
1326                            name: $node.attr('label'),
1327                            disabled: !!$node.attr('disabled'),
1328                            callback: (function(){ return function(){ $node.click(); }; })()
1329                        };
1330                        break;
1331                       
1332                    case 'checkbox':
1333                        item = {
1334                            type: 'checkbox',
1335                            disabled: !!$node.attr('disabled'),
1336                            name: $node.attr('label'),
1337                            selected: !!$node.attr('checked')
1338                        };
1339                        break;
1340                       
1341                    case 'radio':
1342                        item = {
1343                            type: 'radio',
1344                            disabled: !!$node.attr('disabled'),
1345                            name: $node.attr('label'),
1346                            radio: $node.attr('radiogroup'),
1347                            value: $node.attr('id'),
1348                            selected: !!$node.attr('checked')
1349                        };
1350                        break;
1351                       
1352                    default:
1353                        item = undefined;
1354                }
1355                break;
1356 
1357            case 'hr':
1358                item = '-------';
1359                break;
1360               
1361            case 'input':
1362                switch ($node.attr('type')) {
1363                    case 'text':
1364                        item = {
1365                            type: 'text',
1366                            name: label || inputLabel(node),
1367                            disabled: !!$node.attr('disabled'),
1368                            value: $node.val()
1369                        };
1370                        break;
1371                       
1372                    case 'checkbox':
1373                        item = {
1374                            type: 'checkbox',
1375                            name: label || inputLabel(node),
1376                            disabled: !!$node.attr('disabled'),
1377                            selected: !!$node.attr('checked')
1378                        };
1379                        break;
1380                       
1381                    case 'radio':
1382                        item = {
1383                            type: 'radio',
1384                            name: label || inputLabel(node),
1385                            disabled: !!$node.attr('disabled'),
1386                            radio: !!$node.attr('name'),
1387                            value: $node.val(),
1388                            selected: !!$node.attr('checked')
1389                        };
1390                        break;
1391                   
1392                    default:
1393                        item = undefined;
1394                        break;
1395                }
1396                break;
1397               
1398            case 'select':
1399                item = {
1400                    type: 'select',
1401                    name: label || inputLabel(node),
1402                    disabled: !!$node.attr('disabled'),
1403                    selected: $node.val(),
1404                    options: {}
1405                };
1406                $node.children().each(function(){
1407                    item.options[this.value] = $(this).text();
1408                });
1409                break;
1410               
1411            case 'textarea':
1412                item = {
1413                    type: 'textarea',
1414                    name: label || inputLabel(node),
1415                    disabled: !!$node.attr('disabled'),
1416                    value: $node.val()
1417                };
1418                break;
1419           
1420            case 'label':
1421                break;
1422           
1423            default:
1424                item = {type: 'html', html: $node.clone(true)};
1425                break;
1426        }
1427       
1428        if (item) {
1429            counter++;
1430            items['key' + counter] = item;
1431        }
1432    });
1433}
1434
1435// convert html5 menu
1436$.contextMenu.fromMenu = function(element) {
1437    var $this = $(element),
1438        items = {};
1439       
1440    menuChildren(items, $this.children());
1441   
1442    return items;
1443};
1444
1445// make defaults accessible
1446$.contextMenu.defaults = defaults;
1447$.contextMenu.types = types;
1448
1449})(jQuery);
Note: See TracBrowser for help on using the repository browser.