| [ Index ] |
PHP Cross Reference of Unnamed Project |
[Summary view] [Print] [Text view]
1 YUI.add('yui2-menu', function(Y) { 2 var YAHOO = Y.YUI2; 3 /* 4 Copyright (c) 2011, Yahoo! Inc. All rights reserved. 5 Code licensed under the BSD License: 6 http://developer.yahoo.com/yui/license.html 7 version: 2.9.0 8 */ 9 10 11 /** 12 * @module menu 13 * @description <p>The Menu family of components features a collection of 14 * controls that make it easy to add menus to your website or web application. 15 * With the Menu Controls you can create website fly-out menus, customized 16 * context menus, or application-style menu bars with just a small amount of 17 * scripting.</p><p>The Menu family of controls features:</p> 18 * <ul> 19 * <li>Keyboard and mouse navigation.</li> 20 * <li>A rich event model that provides access to all of a menu's 21 * interesting moments.</li> 22 * <li>Support for 23 * <a href="http://en.wikipedia.org/wiki/Progressive_Enhancement">Progressive 24 * Enhancement</a>; Menus can be created from simple, 25 * semantic markup on the page or purely through JavaScript.</li> 26 * </ul> 27 * @title Menu 28 * @namespace YAHOO.widget 29 * @requires Event, Dom, Container 30 */ 31 (function () { 32 33 var UA = YAHOO.env.ua, 34 Dom = YAHOO.util.Dom, 35 Event = YAHOO.util.Event, 36 Lang = YAHOO.lang, 37 38 _DIV = "DIV", 39 _HD = "hd", 40 _BD = "bd", 41 _FT = "ft", 42 _LI = "LI", 43 _DISABLED = "disabled", 44 _MOUSEOVER = "mouseover", 45 _MOUSEOUT = "mouseout", 46 _MOUSEDOWN = "mousedown", 47 _MOUSEUP = "mouseup", 48 _CLICK = "click", 49 _KEYDOWN = "keydown", 50 _KEYUP = "keyup", 51 _KEYPRESS = "keypress", 52 _CLICK_TO_HIDE = "clicktohide", 53 _POSITION = "position", 54 _DYNAMIC = "dynamic", 55 _SHOW_DELAY = "showdelay", 56 _SELECTED = "selected", 57 _VISIBLE = "visible", 58 _UL = "UL", 59 _MENUMANAGER = "MenuManager"; 60 61 62 /** 63 * Singleton that manages a collection of all menus and menu items. Listens 64 * for DOM events at the document level and dispatches the events to the 65 * corresponding menu or menu item. 66 * 67 * @namespace YAHOO.widget 68 * @class MenuManager 69 * @static 70 */ 71 YAHOO.widget.MenuManager = function () { 72 73 // Private member variables 74 75 76 // Flag indicating if the DOM event handlers have been attached 77 78 var m_bInitializedEventHandlers = false, 79 80 81 // Collection of menus 82 83 m_oMenus = {}, 84 85 86 // Collection of visible menus 87 88 m_oVisibleMenus = {}, 89 90 91 // Collection of menu items 92 93 m_oItems = {}, 94 95 96 // Map of DOM event types to their equivalent CustomEvent types 97 98 m_oEventTypes = { 99 "click": "clickEvent", 100 "mousedown": "mouseDownEvent", 101 "mouseup": "mouseUpEvent", 102 "mouseover": "mouseOverEvent", 103 "mouseout": "mouseOutEvent", 104 "keydown": "keyDownEvent", 105 "keyup": "keyUpEvent", 106 "keypress": "keyPressEvent", 107 "focus": "focusEvent", 108 "focusin": "focusEvent", 109 "blur": "blurEvent", 110 "focusout": "blurEvent" 111 }, 112 113 114 m_oFocusedMenuItem = null; 115 116 117 118 // Private methods 119 120 121 /** 122 * @method getMenuRootElement 123 * @description Finds the root DIV node of a menu or the root LI node of 124 * a menu item. 125 * @private 126 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 127 * level-one-html.html#ID-58190037">HTMLElement</a>} p_oElement Object 128 * specifying an HTML element. 129 */ 130 function getMenuRootElement(p_oElement) { 131 132 var oParentNode, 133 returnVal; 134 135 if (p_oElement && p_oElement.tagName) { 136 137 switch (p_oElement.tagName.toUpperCase()) { 138 139 case _DIV: 140 141 oParentNode = p_oElement.parentNode; 142 143 // Check if the DIV is the inner "body" node of a menu 144 145 if (( 146 Dom.hasClass(p_oElement, _HD) || 147 Dom.hasClass(p_oElement, _BD) || 148 Dom.hasClass(p_oElement, _FT) 149 ) && 150 oParentNode && 151 oParentNode.tagName && 152 oParentNode.tagName.toUpperCase() == _DIV) { 153 154 returnVal = oParentNode; 155 156 } 157 else { 158 159 returnVal = p_oElement; 160 161 } 162 163 break; 164 165 case _LI: 166 167 returnVal = p_oElement; 168 169 break; 170 171 default: 172 173 oParentNode = p_oElement.parentNode; 174 175 if (oParentNode) { 176 177 returnVal = getMenuRootElement(oParentNode); 178 179 } 180 181 break; 182 183 } 184 185 } 186 187 return returnVal; 188 189 } 190 191 192 193 // Private event handlers 194 195 196 /** 197 * @method onDOMEvent 198 * @description Generic, global event handler for all of a menu's 199 * DOM-based events. This listens for events against the document 200 * object. If the target of a given event is a member of a menu or 201 * menu item's DOM, the instance's corresponding Custom Event is fired. 202 * @private 203 * @param {Event} p_oEvent Object representing the DOM event object 204 * passed back by the event utility (YAHOO.util.Event). 205 */ 206 function onDOMEvent(p_oEvent) { 207 208 // Get the target node of the DOM event 209 210 var oTarget = Event.getTarget(p_oEvent), 211 212 // See if the target of the event was a menu, or a menu item 213 214 oElement = getMenuRootElement(oTarget), 215 bFireEvent = true, 216 sEventType = p_oEvent.type, 217 sCustomEventType, 218 sTagName, 219 sId, 220 oMenuItem, 221 oMenu; 222 223 224 if (oElement) { 225 226 sTagName = oElement.tagName.toUpperCase(); 227 228 if (sTagName == _LI) { 229 230 sId = oElement.id; 231 232 if (sId && m_oItems[sId]) { 233 234 oMenuItem = m_oItems[sId]; 235 oMenu = oMenuItem.parent; 236 237 } 238 239 } 240 else if (sTagName == _DIV) { 241 242 if (oElement.id) { 243 244 oMenu = m_oMenus[oElement.id]; 245 246 } 247 248 } 249 250 } 251 252 253 if (oMenu) { 254 255 sCustomEventType = m_oEventTypes[sEventType]; 256 257 /* 258 There is an inconsistency between Firefox for Mac OS X and 259 Firefox Windows & Linux regarding the triggering of the 260 display of the browser's context menu and the subsequent 261 firing of the "click" event. In Firefox for Windows & Linux, 262 when the user triggers the display of the browser's context 263 menu the "click" event also fires for the document object, 264 even though the "click" event did not fire for the element 265 that was the original target of the "contextmenu" event. 266 This is unique to Firefox on Windows & Linux. For all 267 other A-Grade browsers, including Firefox for Mac OS X, the 268 "click" event doesn't fire for the document object. 269 270 This bug in Firefox for Windows affects Menu, as Menu 271 instances listen for events at the document level and 272 dispatches Custom Events of the same name. Therefore users 273 of Menu will get an unwanted firing of the "click" 274 custom event. The following line fixes this bug. 275 */ 276 277 278 279 if (sEventType == "click" && 280 (UA.gecko && oMenu.platform != "mac") && 281 p_oEvent.button > 0) { 282 283 bFireEvent = false; 284 285 } 286 287 // Fire the Custom Event that corresponds the current DOM event 288 289 if (bFireEvent && oMenuItem && !oMenuItem.cfg.getProperty(_DISABLED)) { 290 oMenuItem[sCustomEventType].fire(p_oEvent); 291 } 292 293 if (bFireEvent) { 294 oMenu[sCustomEventType].fire(p_oEvent, oMenuItem); 295 } 296 297 } 298 else if (sEventType == _MOUSEDOWN) { 299 300 /* 301 If the target of the event wasn't a menu, hide all 302 dynamically positioned menus 303 */ 304 305 for (var i in m_oVisibleMenus) { 306 307 if (Lang.hasOwnProperty(m_oVisibleMenus, i)) { 308 309 oMenu = m_oVisibleMenus[i]; 310 311 if (oMenu.cfg.getProperty(_CLICK_TO_HIDE) && 312 !(oMenu instanceof YAHOO.widget.MenuBar) && 313 oMenu.cfg.getProperty(_POSITION) == _DYNAMIC) { 314 315 oMenu.hide(); 316 317 // In IE when the user mouses down on a focusable 318 // element that element will be focused and become 319 // the "activeElement". 320 // (http://msdn.microsoft.com/en-us/library/ms533065(VS.85).aspx) 321 // However, there is a bug in IE where if there is 322 // a positioned element with a focused descendant 323 // that is hidden in response to the mousedown 324 // event, the target of the mousedown event will 325 // appear to have focus, but will not be set as 326 // the activeElement. This will result in the 327 // element not firing key events, even though it 328 // appears to have focus. The following call to 329 // "setActive" fixes this bug. 330 331 if (UA.ie && oTarget.focus && (UA.ie < 9)) { 332 oTarget.setActive(); 333 } 334 335 } 336 else { 337 338 if (oMenu.cfg.getProperty(_SHOW_DELAY) > 0) { 339 340 oMenu._cancelShowDelay(); 341 342 } 343 344 345 if (oMenu.activeItem) { 346 347 oMenu.activeItem.blur(); 348 oMenu.activeItem.cfg.setProperty(_SELECTED, false); 349 350 oMenu.activeItem = null; 351 352 } 353 354 } 355 356 } 357 358 } 359 360 } 361 362 } 363 364 365 /** 366 * @method onMenuDestroy 367 * @description "destroy" event handler for a menu. 368 * @private 369 * @param {String} p_sType String representing the name of the event 370 * that was fired. 371 * @param {Array} p_aArgs Array of arguments sent when the event 372 * was fired. 373 * @param {YAHOO.widget.Menu} p_oMenu The menu that fired the event. 374 */ 375 function onMenuDestroy(p_sType, p_aArgs, p_oMenu) { 376 377 if (m_oMenus[p_oMenu.id]) { 378 379 this.removeMenu(p_oMenu); 380 381 } 382 383 } 384 385 386 /** 387 * @method onMenuFocus 388 * @description "focus" event handler for a MenuItem instance. 389 * @private 390 * @param {String} p_sType String representing the name of the event 391 * that was fired. 392 * @param {Array} p_aArgs Array of arguments sent when the event 393 * was fired. 394 */ 395 function onMenuFocus(p_sType, p_aArgs) { 396 397 var oItem = p_aArgs[1]; 398 399 if (oItem) { 400 401 m_oFocusedMenuItem = oItem; 402 403 } 404 405 } 406 407 408 /** 409 * @method onMenuBlur 410 * @description "blur" event handler for a MenuItem instance. 411 * @private 412 * @param {String} p_sType String representing the name of the event 413 * that was fired. 414 * @param {Array} p_aArgs Array of arguments sent when the event 415 * was fired. 416 */ 417 function onMenuBlur(p_sType, p_aArgs) { 418 419 m_oFocusedMenuItem = null; 420 421 } 422 423 424 /** 425 * @method onMenuVisibleConfigChange 426 * @description Event handler for when the "visible" configuration 427 * property of a Menu instance changes. 428 * @private 429 * @param {String} p_sType String representing the name of the event 430 * that was fired. 431 * @param {Array} p_aArgs Array of arguments sent when the event 432 * was fired. 433 */ 434 function onMenuVisibleConfigChange(p_sType, p_aArgs) { 435 436 var bVisible = p_aArgs[0], 437 sId = this.id; 438 439 if (bVisible) { 440 441 m_oVisibleMenus[sId] = this; 442 443 YAHOO.log(this + " added to the collection of visible menus.", 444 "info", _MENUMANAGER); 445 446 } 447 else if (m_oVisibleMenus[sId]) { 448 449 delete m_oVisibleMenus[sId]; 450 451 YAHOO.log(this + " removed from the collection of visible menus.", 452 "info", _MENUMANAGER); 453 454 } 455 456 } 457 458 459 /** 460 * @method onItemDestroy 461 * @description "destroy" event handler for a MenuItem instance. 462 * @private 463 * @param {String} p_sType String representing the name of the event 464 * that was fired. 465 * @param {Array} p_aArgs Array of arguments sent when the event 466 * was fired. 467 */ 468 function onItemDestroy(p_sType, p_aArgs) { 469 470 removeItem(this); 471 472 } 473 474 475 /** 476 * @method removeItem 477 * @description Removes a MenuItem instance from the MenuManager's collection of MenuItems. 478 * @private 479 * @param {MenuItem} p_oMenuItem The MenuItem instance to be removed. 480 */ 481 function removeItem(p_oMenuItem) { 482 483 var sId = p_oMenuItem.id; 484 485 if (sId && m_oItems[sId]) { 486 487 if (m_oFocusedMenuItem == p_oMenuItem) { 488 489 m_oFocusedMenuItem = null; 490 491 } 492 493 delete m_oItems[sId]; 494 495 p_oMenuItem.destroyEvent.unsubscribe(onItemDestroy); 496 497 YAHOO.log(p_oMenuItem + " successfully unregistered.", "info", _MENUMANAGER); 498 499 } 500 501 } 502 503 504 /** 505 * @method onItemAdded 506 * @description "itemadded" event handler for a Menu instance. 507 * @private 508 * @param {String} p_sType String representing the name of the event 509 * that was fired. 510 * @param {Array} p_aArgs Array of arguments sent when the event 511 * was fired. 512 */ 513 function onItemAdded(p_sType, p_aArgs) { 514 515 var oItem = p_aArgs[0], 516 sId; 517 518 if (oItem instanceof YAHOO.widget.MenuItem) { 519 520 sId = oItem.id; 521 522 if (!m_oItems[sId]) { 523 524 m_oItems[sId] = oItem; 525 526 oItem.destroyEvent.subscribe(onItemDestroy); 527 528 YAHOO.log(oItem + " successfully registered.", "info", _MENUMANAGER); 529 530 } 531 532 } 533 534 } 535 536 537 return { 538 539 // Privileged methods 540 541 542 /** 543 * @method addMenu 544 * @description Adds a menu to the collection of known menus. 545 * @param {YAHOO.widget.Menu} p_oMenu Object specifying the Menu 546 * instance to be added. 547 */ 548 addMenu: function (p_oMenu) { 549 550 var oDoc; 551 552 if (p_oMenu instanceof YAHOO.widget.Menu && p_oMenu.id && 553 !m_oMenus[p_oMenu.id]) { 554 555 m_oMenus[p_oMenu.id] = p_oMenu; 556 557 558 if (!m_bInitializedEventHandlers) { 559 560 oDoc = document; 561 562 Event.on(oDoc, _MOUSEOVER, onDOMEvent, this, true); 563 Event.on(oDoc, _MOUSEOUT, onDOMEvent, this, true); 564 Event.on(oDoc, _MOUSEDOWN, onDOMEvent, this, true); 565 Event.on(oDoc, _MOUSEUP, onDOMEvent, this, true); 566 Event.on(oDoc, _CLICK, onDOMEvent, this, true); 567 Event.on(oDoc, _KEYDOWN, onDOMEvent, this, true); 568 Event.on(oDoc, _KEYUP, onDOMEvent, this, true); 569 Event.on(oDoc, _KEYPRESS, onDOMEvent, this, true); 570 571 Event.onFocus(oDoc, onDOMEvent, this, true); 572 Event.onBlur(oDoc, onDOMEvent, this, true); 573 574 m_bInitializedEventHandlers = true; 575 576 YAHOO.log("DOM event handlers initialized.", "info", _MENUMANAGER); 577 578 } 579 580 p_oMenu.cfg.subscribeToConfigEvent(_VISIBLE, onMenuVisibleConfigChange); 581 p_oMenu.destroyEvent.subscribe(onMenuDestroy, p_oMenu, this); 582 p_oMenu.itemAddedEvent.subscribe(onItemAdded); 583 p_oMenu.focusEvent.subscribe(onMenuFocus); 584 p_oMenu.blurEvent.subscribe(onMenuBlur); 585 586 YAHOO.log(p_oMenu + " successfully registered.", "info", _MENUMANAGER); 587 588 } 589 590 }, 591 592 593 /** 594 * @method removeMenu 595 * @description Removes a menu from the collection of known menus. 596 * @param {YAHOO.widget.Menu} p_oMenu Object specifying the Menu 597 * instance to be removed. 598 */ 599 removeMenu: function (p_oMenu) { 600 601 var sId, 602 aItems, 603 i; 604 605 if (p_oMenu) { 606 607 sId = p_oMenu.id; 608 609 if ((sId in m_oMenus) && (m_oMenus[sId] == p_oMenu)) { 610 611 // Unregister each menu item 612 613 aItems = p_oMenu.getItems(); 614 615 if (aItems && aItems.length > 0) { 616 617 i = aItems.length - 1; 618 619 do { 620 621 removeItem(aItems[i]); 622 623 } 624 while (i--); 625 626 } 627 628 629 // Unregister the menu 630 631 delete m_oMenus[sId]; 632 633 YAHOO.log(p_oMenu + " successfully unregistered.", "info", _MENUMANAGER); 634 635 636 /* 637 Unregister the menu from the collection of 638 visible menus 639 */ 640 641 if ((sId in m_oVisibleMenus) && (m_oVisibleMenus[sId] == p_oMenu)) { 642 643 delete m_oVisibleMenus[sId]; 644 645 YAHOO.log(p_oMenu + " unregistered from the" + 646 " collection of visible menus.", "info", _MENUMANAGER); 647 648 } 649 650 651 // Unsubscribe event listeners 652 653 if (p_oMenu.cfg) { 654 655 p_oMenu.cfg.unsubscribeFromConfigEvent(_VISIBLE, 656 onMenuVisibleConfigChange); 657 658 } 659 660 p_oMenu.destroyEvent.unsubscribe(onMenuDestroy, 661 p_oMenu); 662 663 p_oMenu.itemAddedEvent.unsubscribe(onItemAdded); 664 p_oMenu.focusEvent.unsubscribe(onMenuFocus); 665 p_oMenu.blurEvent.unsubscribe(onMenuBlur); 666 667 } 668 669 } 670 671 }, 672 673 674 /** 675 * @method hideVisible 676 * @description Hides all visible, dynamically positioned menus 677 * (excluding instances of YAHOO.widget.MenuBar). 678 */ 679 hideVisible: function () { 680 681 var oMenu; 682 683 for (var i in m_oVisibleMenus) { 684 685 if (Lang.hasOwnProperty(m_oVisibleMenus, i)) { 686 687 oMenu = m_oVisibleMenus[i]; 688 689 if (!(oMenu instanceof YAHOO.widget.MenuBar) && 690 oMenu.cfg.getProperty(_POSITION) == _DYNAMIC) { 691 692 oMenu.hide(); 693 694 } 695 696 } 697 698 } 699 700 }, 701 702 703 /** 704 * @method getVisible 705 * @description Returns a collection of all visible menus registered 706 * with the menu manger. 707 * @return {Object} 708 */ 709 getVisible: function () { 710 711 return m_oVisibleMenus; 712 713 }, 714 715 716 /** 717 * @method getMenus 718 * @description Returns a collection of all menus registered with the 719 * menu manger. 720 * @return {Object} 721 */ 722 getMenus: function () { 723 724 return m_oMenus; 725 726 }, 727 728 729 /** 730 * @method getMenu 731 * @description Returns a menu with the specified id. 732 * @param {String} p_sId String specifying the id of the 733 * <code><div></code> element representing the menu to 734 * be retrieved. 735 * @return {YAHOO.widget.Menu} 736 */ 737 getMenu: function (p_sId) { 738 739 var returnVal; 740 741 if (p_sId in m_oMenus) { 742 743 returnVal = m_oMenus[p_sId]; 744 745 } 746 747 return returnVal; 748 749 }, 750 751 752 /** 753 * @method getMenuItem 754 * @description Returns a menu item with the specified id. 755 * @param {String} p_sId String specifying the id of the 756 * <code><li></code> element representing the menu item to 757 * be retrieved. 758 * @return {YAHOO.widget.MenuItem} 759 */ 760 getMenuItem: function (p_sId) { 761 762 var returnVal; 763 764 if (p_sId in m_oItems) { 765 766 returnVal = m_oItems[p_sId]; 767 768 } 769 770 return returnVal; 771 772 }, 773 774 775 /** 776 * @method getMenuItemGroup 777 * @description Returns an array of menu item instances whose 778 * corresponding <code><li></code> elements are child 779 * nodes of the <code><ul></code> element with the 780 * specified id. 781 * @param {String} p_sId String specifying the id of the 782 * <code><ul></code> element representing the group of 783 * menu items to be retrieved. 784 * @return {Array} 785 */ 786 getMenuItemGroup: function (p_sId) { 787 788 var oUL = Dom.get(p_sId), 789 aItems, 790 oNode, 791 oItem, 792 sId, 793 returnVal; 794 795 796 if (oUL && oUL.tagName && oUL.tagName.toUpperCase() == _UL) { 797 798 oNode = oUL.firstChild; 799 800 if (oNode) { 801 802 aItems = []; 803 804 do { 805 806 sId = oNode.id; 807 808 if (sId) { 809 810 oItem = this.getMenuItem(sId); 811 812 if (oItem) { 813 814 aItems[aItems.length] = oItem; 815 816 } 817 818 } 819 820 } 821 while ((oNode = oNode.nextSibling)); 822 823 824 if (aItems.length > 0) { 825 826 returnVal = aItems; 827 828 } 829 830 } 831 832 } 833 834 return returnVal; 835 836 }, 837 838 839 /** 840 * @method getFocusedMenuItem 841 * @description Returns a reference to the menu item that currently 842 * has focus. 843 * @return {YAHOO.widget.MenuItem} 844 */ 845 getFocusedMenuItem: function () { 846 847 return m_oFocusedMenuItem; 848 849 }, 850 851 852 /** 853 * @method getFocusedMenu 854 * @description Returns a reference to the menu that currently 855 * has focus. 856 * @return {YAHOO.widget.Menu} 857 */ 858 getFocusedMenu: function () { 859 860 var returnVal; 861 862 if (m_oFocusedMenuItem) { 863 864 returnVal = m_oFocusedMenuItem.parent.getRoot(); 865 866 } 867 868 return returnVal; 869 870 }, 871 872 873 /** 874 * @method toString 875 * @description Returns a string representing the menu manager. 876 * @return {String} 877 */ 878 toString: function () { 879 880 return _MENUMANAGER; 881 882 } 883 884 }; 885 886 }(); 887 888 })(); 889 890 891 892 (function () { 893 894 var Lang = YAHOO.lang, 895 896 // String constants 897 898 _MENU = "Menu", 899 _DIV_UPPERCASE = "DIV", 900 _DIV_LOWERCASE = "div", 901 _ID = "id", 902 _SELECT = "SELECT", 903 _XY = "xy", 904 _Y = "y", 905 _UL_UPPERCASE = "UL", 906 _UL_LOWERCASE = "ul", 907 _FIRST_OF_TYPE = "first-of-type", 908 _LI = "LI", 909 _OPTGROUP = "OPTGROUP", 910 _OPTION = "OPTION", 911 _DISABLED = "disabled", 912 _NONE = "none", 913 _SELECTED = "selected", 914 _GROUP_INDEX = "groupindex", 915 _INDEX = "index", 916 _SUBMENU = "submenu", 917 _VISIBLE = "visible", 918 _HIDE_DELAY = "hidedelay", 919 _POSITION = "position", 920 _DYNAMIC = "dynamic", 921 _STATIC = "static", 922 _DYNAMIC_STATIC = _DYNAMIC + "," + _STATIC, 923 _URL = "url", 924 _HASH = "#", 925 _TARGET = "target", 926 _MAX_HEIGHT = "maxheight", 927 _TOP_SCROLLBAR = "topscrollbar", 928 _BOTTOM_SCROLLBAR = "bottomscrollbar", 929 _UNDERSCORE = "_", 930 _TOP_SCROLLBAR_DISABLED = _TOP_SCROLLBAR + _UNDERSCORE + _DISABLED, 931 _BOTTOM_SCROLLBAR_DISABLED = _BOTTOM_SCROLLBAR + _UNDERSCORE + _DISABLED, 932 _MOUSEMOVE = "mousemove", 933 _SHOW_DELAY = "showdelay", 934 _SUBMENU_HIDE_DELAY = "submenuhidedelay", 935 _IFRAME = "iframe", 936 _CONSTRAIN_TO_VIEWPORT = "constraintoviewport", 937 _PREVENT_CONTEXT_OVERLAP = "preventcontextoverlap", 938 _SUBMENU_ALIGNMENT = "submenualignment", 939 _AUTO_SUBMENU_DISPLAY = "autosubmenudisplay", 940 _CLICK_TO_HIDE = "clicktohide", 941 _CONTAINER = "container", 942 _SCROLL_INCREMENT = "scrollincrement", 943 _MIN_SCROLL_HEIGHT = "minscrollheight", 944 _CLASSNAME = "classname", 945 _SHADOW = "shadow", 946 _KEEP_OPEN = "keepopen", 947 _HD = "hd", 948 _HAS_TITLE = "hastitle", 949 _CONTEXT = "context", 950 _EMPTY_STRING = "", 951 _MOUSEDOWN = "mousedown", 952 _KEYDOWN = "keydown", 953 _HEIGHT = "height", 954 _WIDTH = "width", 955 _PX = "px", 956 _EFFECT = "effect", 957 _MONITOR_RESIZE = "monitorresize", 958 _DISPLAY = "display", 959 _BLOCK = "block", 960 _VISIBILITY = "visibility", 961 _ABSOLUTE = "absolute", 962 _ZINDEX = "zindex", 963 _YUI_MENU_BODY_SCROLLED = "yui-menu-body-scrolled", 964 _NON_BREAKING_SPACE = " ", 965 _SPACE = " ", 966 _MOUSEOVER = "mouseover", 967 _MOUSEOUT = "mouseout", 968 _ITEM_ADDED = "itemAdded", 969 _ITEM_REMOVED = "itemRemoved", 970 _HIDDEN = "hidden", 971 _YUI_MENU_SHADOW = "yui-menu-shadow", 972 _YUI_MENU_SHADOW_VISIBLE = _YUI_MENU_SHADOW + "-visible", 973 _YUI_MENU_SHADOW_YUI_MENU_SHADOW_VISIBLE = _YUI_MENU_SHADOW + _SPACE + _YUI_MENU_SHADOW_VISIBLE; 974 975 976 /** 977 * The Menu class creates a container that holds a vertical list representing 978 * a set of options or commands. Menu is the base class for all 979 * menu containers. 980 * @param {String} p_oElement String specifying the id attribute of the 981 * <code><div></code> element of the menu. 982 * @param {String} p_oElement String specifying the id attribute of the 983 * <code><select></code> element to be used as the data source 984 * for the menu. 985 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 986 * level-one-html.html#ID-22445964">HTMLDivElement</a>} p_oElement Object 987 * specifying the <code><div></code> element of the menu. 988 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 989 * level-one-html.html#ID-94282980">HTMLSelectElement</a>} p_oElement 990 * Object specifying the <code><select></code> element to be used as 991 * the data source for the menu. 992 * @param {Object} p_oConfig Optional. Object literal specifying the 993 * configuration for the menu. See configuration class documentation for 994 * more details. 995 * @namespace YAHOO.widget 996 * @class Menu 997 * @constructor 998 * @extends YAHOO.widget.Overlay 999 */ 1000 YAHOO.widget.Menu = function (p_oElement, p_oConfig) { 1001 1002 if (p_oConfig) { 1003 this.parent = p_oConfig.parent; 1004 this.lazyLoad = p_oConfig.lazyLoad || p_oConfig.lazyload; 1005 this.itemData = p_oConfig.itemData || p_oConfig.itemdata; 1006 } 1007 1008 YAHOO.widget.Menu.superclass.constructor.call(this, p_oElement, p_oConfig); 1009 }; 1010 1011 1012 1013 /** 1014 * @method checkPosition 1015 * @description Checks to make sure that the value of the "position" property 1016 * is one of the supported strings. Returns true if the position is supported. 1017 * @private 1018 * @param {Object} p_sPosition String specifying the position of the menu. 1019 * @return {Boolean} 1020 */ 1021 function checkPosition(p_sPosition) { 1022 1023 var returnVal = false; 1024 1025 if (Lang.isString(p_sPosition)) { 1026 1027 returnVal = (_DYNAMIC_STATIC.indexOf((p_sPosition.toLowerCase())) != -1); 1028 1029 } 1030 1031 return returnVal; 1032 1033 } 1034 1035 1036 var Dom = YAHOO.util.Dom, 1037 Event = YAHOO.util.Event, 1038 Module = YAHOO.widget.Module, 1039 Overlay = YAHOO.widget.Overlay, 1040 Menu = YAHOO.widget.Menu, 1041 MenuManager = YAHOO.widget.MenuManager, 1042 CustomEvent = YAHOO.util.CustomEvent, 1043 UA = YAHOO.env.ua, 1044 1045 m_oShadowTemplate, 1046 1047 bFocusListenerInitialized = false, 1048 1049 oFocusedElement, 1050 1051 EVENT_TYPES = [ 1052 1053 ["mouseOverEvent", _MOUSEOVER], 1054 ["mouseOutEvent", _MOUSEOUT], 1055 ["mouseDownEvent", _MOUSEDOWN], 1056 ["mouseUpEvent", "mouseup"], 1057 ["clickEvent", "click"], 1058 ["keyPressEvent", "keypress"], 1059 ["keyDownEvent", _KEYDOWN], 1060 ["keyUpEvent", "keyup"], 1061 ["focusEvent", "focus"], 1062 ["blurEvent", "blur"], 1063 ["itemAddedEvent", _ITEM_ADDED], 1064 ["itemRemovedEvent", _ITEM_REMOVED] 1065 1066 ], 1067 1068 VISIBLE_CONFIG = { 1069 key: _VISIBLE, 1070 value: false, 1071 validator: Lang.isBoolean 1072 }, 1073 1074 CONSTRAIN_TO_VIEWPORT_CONFIG = { 1075 key: _CONSTRAIN_TO_VIEWPORT, 1076 value: true, 1077 validator: Lang.isBoolean, 1078 supercedes: [_IFRAME,"x",_Y,_XY] 1079 }, 1080 1081 PREVENT_CONTEXT_OVERLAP_CONFIG = { 1082 key: _PREVENT_CONTEXT_OVERLAP, 1083 value: true, 1084 validator: Lang.isBoolean, 1085 supercedes: [_CONSTRAIN_TO_VIEWPORT] 1086 }, 1087 1088 POSITION_CONFIG = { 1089 key: _POSITION, 1090 value: _DYNAMIC, 1091 validator: checkPosition, 1092 supercedes: [_VISIBLE, _IFRAME] 1093 }, 1094 1095 SUBMENU_ALIGNMENT_CONFIG = { 1096 key: _SUBMENU_ALIGNMENT, 1097 value: ["tl","tr"] 1098 }, 1099 1100 AUTO_SUBMENU_DISPLAY_CONFIG = { 1101 key: _AUTO_SUBMENU_DISPLAY, 1102 value: true, 1103 validator: Lang.isBoolean, 1104 suppressEvent: true 1105 }, 1106 1107 SHOW_DELAY_CONFIG = { 1108 key: _SHOW_DELAY, 1109 value: 250, 1110 validator: Lang.isNumber, 1111 suppressEvent: true 1112 }, 1113 1114 HIDE_DELAY_CONFIG = { 1115 key: _HIDE_DELAY, 1116 value: 0, 1117 validator: Lang.isNumber, 1118 suppressEvent: true 1119 }, 1120 1121 SUBMENU_HIDE_DELAY_CONFIG = { 1122 key: _SUBMENU_HIDE_DELAY, 1123 value: 250, 1124 validator: Lang.isNumber, 1125 suppressEvent: true 1126 }, 1127 1128 CLICK_TO_HIDE_CONFIG = { 1129 key: _CLICK_TO_HIDE, 1130 value: true, 1131 validator: Lang.isBoolean, 1132 suppressEvent: true 1133 }, 1134 1135 CONTAINER_CONFIG = { 1136 key: _CONTAINER, 1137 suppressEvent: true 1138 }, 1139 1140 SCROLL_INCREMENT_CONFIG = { 1141 key: _SCROLL_INCREMENT, 1142 value: 1, 1143 validator: Lang.isNumber, 1144 supercedes: [_MAX_HEIGHT], 1145 suppressEvent: true 1146 }, 1147 1148 MIN_SCROLL_HEIGHT_CONFIG = { 1149 key: _MIN_SCROLL_HEIGHT, 1150 value: 90, 1151 validator: Lang.isNumber, 1152 supercedes: [_MAX_HEIGHT], 1153 suppressEvent: true 1154 }, 1155 1156 MAX_HEIGHT_CONFIG = { 1157 key: _MAX_HEIGHT, 1158 value: 0, 1159 validator: Lang.isNumber, 1160 supercedes: [_IFRAME], 1161 suppressEvent: true 1162 }, 1163 1164 CLASS_NAME_CONFIG = { 1165 key: _CLASSNAME, 1166 value: null, 1167 validator: Lang.isString, 1168 suppressEvent: true 1169 }, 1170 1171 DISABLED_CONFIG = { 1172 key: _DISABLED, 1173 value: false, 1174 validator: Lang.isBoolean, 1175 suppressEvent: true 1176 }, 1177 1178 SHADOW_CONFIG = { 1179 key: _SHADOW, 1180 value: true, 1181 validator: Lang.isBoolean, 1182 suppressEvent: true, 1183 supercedes: [_VISIBLE] 1184 }, 1185 1186 KEEP_OPEN_CONFIG = { 1187 key: _KEEP_OPEN, 1188 value: false, 1189 validator: Lang.isBoolean 1190 }; 1191 1192 1193 function onDocFocus(event) { 1194 1195 oFocusedElement = Event.getTarget(event); 1196 1197 } 1198 1199 1200 1201 YAHOO.lang.extend(Menu, Overlay, { 1202 1203 1204 // Constants 1205 1206 1207 /** 1208 * @property CSS_CLASS_NAME 1209 * @description String representing the CSS class(es) to be applied to the 1210 * menu's <code><div></code> element. 1211 * @default "yuimenu" 1212 * @final 1213 * @type String 1214 */ 1215 CSS_CLASS_NAME: "yuimenu", 1216 1217 1218 /** 1219 * @property ITEM_TYPE 1220 * @description Object representing the type of menu item to instantiate and 1221 * add when parsing the child nodes (either <code><li></code> element, 1222 * <code><optgroup></code> element or <code><option></code>) 1223 * of the menu's source HTML element. 1224 * @default YAHOO.widget.MenuItem 1225 * @final 1226 * @type YAHOO.widget.MenuItem 1227 */ 1228 ITEM_TYPE: null, 1229 1230 1231 /** 1232 * @property GROUP_TITLE_TAG_NAME 1233 * @description String representing the tagname of the HTML element used to 1234 * title the menu's item groups. 1235 * @default H6 1236 * @final 1237 * @type String 1238 */ 1239 GROUP_TITLE_TAG_NAME: "h6", 1240 1241 1242 /** 1243 * @property OFF_SCREEN_POSITION 1244 * @description Array representing the default x and y position that a menu 1245 * should have when it is positioned outside the viewport by the 1246 * "poistionOffScreen" method. 1247 * @default "-999em" 1248 * @final 1249 * @type String 1250 */ 1251 OFF_SCREEN_POSITION: "-999em", 1252 1253 1254 // Private properties 1255 1256 1257 /** 1258 * @property _useHideDelay 1259 * @description Boolean indicating if the "mouseover" and "mouseout" event 1260 * handlers used for hiding the menu via a call to "YAHOO.lang.later" have 1261 * already been assigned. 1262 * @default false 1263 * @private 1264 * @type Boolean 1265 */ 1266 _useHideDelay: false, 1267 1268 1269 /** 1270 * @property _bHandledMouseOverEvent 1271 * @description Boolean indicating the current state of the menu's 1272 * "mouseover" event. 1273 * @default false 1274 * @private 1275 * @type Boolean 1276 */ 1277 _bHandledMouseOverEvent: false, 1278 1279 1280 /** 1281 * @property _bHandledMouseOutEvent 1282 * @description Boolean indicating the current state of the menu's 1283 * "mouseout" event. 1284 * @default false 1285 * @private 1286 * @type Boolean 1287 */ 1288 _bHandledMouseOutEvent: false, 1289 1290 1291 /** 1292 * @property _aGroupTitleElements 1293 * @description Array of HTML element used to title groups of menu items. 1294 * @default [] 1295 * @private 1296 * @type Array 1297 */ 1298 _aGroupTitleElements: null, 1299 1300 1301 /** 1302 * @property _aItemGroups 1303 * @description Multi-dimensional Array representing the menu items as they 1304 * are grouped in the menu. 1305 * @default [] 1306 * @private 1307 * @type Array 1308 */ 1309 _aItemGroups: null, 1310 1311 1312 /** 1313 * @property _aListElements 1314 * @description Array of <code><ul></code> elements, each of which is 1315 * the parent node for each item's <code><li></code> element. 1316 * @default [] 1317 * @private 1318 * @type Array 1319 */ 1320 _aListElements: null, 1321 1322 1323 /** 1324 * @property _nCurrentMouseX 1325 * @description The current x coordinate of the mouse inside the area of 1326 * the menu. 1327 * @default 0 1328 * @private 1329 * @type Number 1330 */ 1331 _nCurrentMouseX: 0, 1332 1333 1334 /** 1335 * @property _bStopMouseEventHandlers 1336 * @description Stops "mouseover," "mouseout," and "mousemove" event handlers 1337 * from executing. 1338 * @default false 1339 * @private 1340 * @type Boolean 1341 */ 1342 _bStopMouseEventHandlers: false, 1343 1344 1345 /** 1346 * @property _sClassName 1347 * @description The current value of the "classname" configuration attribute. 1348 * @default null 1349 * @private 1350 * @type String 1351 */ 1352 _sClassName: null, 1353 1354 1355 1356 // Public properties 1357 1358 1359 /** 1360 * @property lazyLoad 1361 * @description Boolean indicating if the menu's "lazy load" feature is 1362 * enabled. If set to "true," initialization and rendering of the menu's 1363 * items will be deferred until the first time it is made visible. This 1364 * property should be set via the constructor using the configuration 1365 * object literal. 1366 * @default false 1367 * @type Boolean 1368 */ 1369 lazyLoad: false, 1370 1371 1372 /** 1373 * @property itemData 1374 * @description Array of items to be added to the menu. The array can contain 1375 * strings representing the text for each item to be created, object literals 1376 * representing the menu item configuration properties, or MenuItem instances. 1377 * This property should be set via the constructor using the configuration 1378 * object literal. 1379 * @default null 1380 * @type Array 1381 */ 1382 itemData: null, 1383 1384 1385 /** 1386 * @property activeItem 1387 * @description Object reference to the item in the menu that has is selected. 1388 * @default null 1389 * @type YAHOO.widget.MenuItem 1390 */ 1391 activeItem: null, 1392 1393 1394 /** 1395 * @property parent 1396 * @description Object reference to the menu's parent menu or menu item. 1397 * This property can be set via the constructor using the configuration 1398 * object literal. 1399 * @default null 1400 * @type YAHOO.widget.MenuItem 1401 */ 1402 parent: null, 1403 1404 1405 /** 1406 * @property srcElement 1407 * @description Object reference to the HTML element (either 1408 * <code><select></code> or <code><div></code>) used to 1409 * create the menu. 1410 * @default null 1411 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 1412 * level-one-html.html#ID-94282980">HTMLSelectElement</a>|<a 1413 * href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-html. 1414 * html#ID-22445964">HTMLDivElement</a> 1415 */ 1416 srcElement: null, 1417 1418 1419 1420 // Events 1421 1422 1423 /** 1424 * @event mouseOverEvent 1425 * @description Fires when the mouse has entered the menu. Passes back 1426 * the DOM Event object as an argument. 1427 */ 1428 1429 1430 /** 1431 * @event mouseOutEvent 1432 * @description Fires when the mouse has left the menu. Passes back the DOM 1433 * Event object as an argument. 1434 * @type YAHOO.util.CustomEvent 1435 */ 1436 1437 1438 /** 1439 * @event mouseDownEvent 1440 * @description Fires when the user mouses down on the menu. Passes back the 1441 * DOM Event object as an argument. 1442 * @type YAHOO.util.CustomEvent 1443 */ 1444 1445 1446 /** 1447 * @event mouseUpEvent 1448 * @description Fires when the user releases a mouse button while the mouse is 1449 * over the menu. Passes back the DOM Event object as an argument. 1450 * @type YAHOO.util.CustomEvent 1451 */ 1452 1453 1454 /** 1455 * @event clickEvent 1456 * @description Fires when the user clicks the on the menu. Passes back the 1457 * DOM Event object as an argument. 1458 * @type YAHOO.util.CustomEvent 1459 */ 1460 1461 1462 /** 1463 * @event keyPressEvent 1464 * @description Fires when the user presses an alphanumeric key when one of the 1465 * menu's items has focus. Passes back the DOM Event object as an argument. 1466 * @type YAHOO.util.CustomEvent 1467 */ 1468 1469 1470 /** 1471 * @event keyDownEvent 1472 * @description Fires when the user presses a key when one of the menu's items 1473 * has focus. Passes back the DOM Event object as an argument. 1474 * @type YAHOO.util.CustomEvent 1475 */ 1476 1477 1478 /** 1479 * @event keyUpEvent 1480 * @description Fires when the user releases a key when one of the menu's items 1481 * has focus. Passes back the DOM Event object as an argument. 1482 * @type YAHOO.util.CustomEvent 1483 */ 1484 1485 1486 /** 1487 * @event itemAddedEvent 1488 * @description Fires when an item is added to the menu. 1489 * @type YAHOO.util.CustomEvent 1490 */ 1491 1492 1493 /** 1494 * @event itemRemovedEvent 1495 * @description Fires when an item is removed to the menu. 1496 * @type YAHOO.util.CustomEvent 1497 */ 1498 1499 1500 /** 1501 * @method init 1502 * @description The Menu class's initialization method. This method is 1503 * automatically called by the constructor, and sets up all DOM references 1504 * for pre-existing markup, and creates required markup if it is not 1505 * already present. 1506 * @param {String} p_oElement String specifying the id attribute of the 1507 * <code><div></code> element of the menu. 1508 * @param {String} p_oElement String specifying the id attribute of the 1509 * <code><select></code> element to be used as the data source 1510 * for the menu. 1511 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 1512 * level-one-html.html#ID-22445964">HTMLDivElement</a>} p_oElement Object 1513 * specifying the <code><div></code> element of the menu. 1514 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 1515 * level-one-html.html#ID-94282980">HTMLSelectElement</a>} p_oElement 1516 * Object specifying the <code><select></code> element to be used as 1517 * the data source for the menu. 1518 * @param {Object} p_oConfig Optional. Object literal specifying the 1519 * configuration for the menu. See configuration class documentation for 1520 * more details. 1521 */ 1522 init: function (p_oElement, p_oConfig) { 1523 1524 this._aItemGroups = []; 1525 this._aListElements = []; 1526 this._aGroupTitleElements = []; 1527 1528 if (!this.ITEM_TYPE) { 1529 1530 this.ITEM_TYPE = YAHOO.widget.MenuItem; 1531 1532 } 1533 1534 1535 var oElement; 1536 1537 if (Lang.isString(p_oElement)) { 1538 1539 oElement = Dom.get(p_oElement); 1540 1541 } 1542 else if (p_oElement.tagName) { 1543 1544 oElement = p_oElement; 1545 1546 } 1547 1548 1549 if (oElement && oElement.tagName) { 1550 1551 switch(oElement.tagName.toUpperCase()) { 1552 1553 case _DIV_UPPERCASE: 1554 1555 this.srcElement = oElement; 1556 1557 if (!oElement.id) { 1558 1559 oElement.setAttribute(_ID, Dom.generateId()); 1560 1561 } 1562 1563 1564 /* 1565 Note: we don't pass the user config in here yet 1566 because we only want it executed once, at the lowest 1567 subclass level. 1568 */ 1569 1570 Menu.superclass.init.call(this, oElement); 1571 1572 this.beforeInitEvent.fire(Menu); 1573 1574 YAHOO.log("Source element: " + this.srcElement.tagName, "info", this.toString()); 1575 1576 break; 1577 1578 case _SELECT: 1579 1580 this.srcElement = oElement; 1581 1582 1583 /* 1584 The source element is not something that we can use 1585 outright, so we need to create a new Overlay 1586 1587 Note: we don't pass the user config in here yet 1588 because we only want it executed once, at the lowest 1589 subclass level. 1590 */ 1591 1592 Menu.superclass.init.call(this, Dom.generateId()); 1593 1594 this.beforeInitEvent.fire(Menu); 1595 1596 YAHOO.log("Source element: " + this.srcElement.tagName, "info", this.toString()); 1597 1598 break; 1599 1600 } 1601 1602 } 1603 else { 1604 1605 /* 1606 Note: we don't pass the user config in here yet 1607 because we only want it executed once, at the lowest 1608 subclass level. 1609 */ 1610 1611 Menu.superclass.init.call(this, p_oElement); 1612 1613 this.beforeInitEvent.fire(Menu); 1614 1615 YAHOO.log("No source element found. Created element with id: " + this.id, "info", this.toString()); 1616 1617 } 1618 1619 1620 if (this.element) { 1621 Dom.addClass(this.element, this.CSS_CLASS_NAME); 1622 1623 // Subscribe to Custom Events 1624 this.initEvent.subscribe(this._onInit); 1625 this.beforeRenderEvent.subscribe(this._onBeforeRender); 1626 this.renderEvent.subscribe(this._onRender); 1627 this.beforeShowEvent.subscribe(this._onBeforeShow); 1628 this.hideEvent.subscribe(this._onHide); 1629 this.showEvent.subscribe(this._onShow); 1630 this.beforeHideEvent.subscribe(this._onBeforeHide); 1631 this.mouseOverEvent.subscribe(this._onMouseOver); 1632 this.mouseOutEvent.subscribe(this._onMouseOut); 1633 this.clickEvent.subscribe(this._onClick); 1634 this.keyDownEvent.subscribe(this._onKeyDown); 1635 this.keyPressEvent.subscribe(this._onKeyPress); 1636 this.blurEvent.subscribe(this._onBlur); 1637 1638 if (!bFocusListenerInitialized) { 1639 Event.onFocus(document, onDocFocus); 1640 bFocusListenerInitialized = true; 1641 } 1642 1643 // Fixes an issue in Firefox 2 and Webkit where Dom's "getX" and "getY" 1644 // methods return values that don't take scrollTop into consideration 1645 1646 if ((UA.gecko && UA.gecko < 1.9) || (UA.webkit && UA.webkit < 523)) { 1647 this.cfg.subscribeToConfigEvent(_Y, this._onYChange); 1648 } 1649 1650 1651 if (p_oConfig) { 1652 this.cfg.applyConfig(p_oConfig, true); 1653 } 1654 1655 // Register the Menu instance with the MenuManager 1656 MenuManager.addMenu(this); 1657 1658 this.initEvent.fire(Menu); 1659 } 1660 }, 1661 1662 1663 1664 // Private methods 1665 1666 1667 /** 1668 * @method _initSubTree 1669 * @description Iterates the childNodes of the source element to find nodes 1670 * used to instantiate menu and menu items. 1671 * @private 1672 */ 1673 _initSubTree: function () { 1674 1675 var oSrcElement = this.srcElement, 1676 sSrcElementTagName, 1677 nGroup, 1678 sGroupTitleTagName, 1679 oNode, 1680 aListElements, 1681 nListElements, 1682 i; 1683 1684 1685 if (oSrcElement) { 1686 1687 sSrcElementTagName = 1688 (oSrcElement.tagName && oSrcElement.tagName.toUpperCase()); 1689 1690 1691 if (sSrcElementTagName == _DIV_UPPERCASE) { 1692 1693 // Populate the collection of item groups and item group titles 1694 1695 oNode = this.body.firstChild; 1696 1697 1698 if (oNode) { 1699 1700 nGroup = 0; 1701 sGroupTitleTagName = this.GROUP_TITLE_TAG_NAME.toUpperCase(); 1702 1703 do { 1704 1705 1706 if (oNode && oNode.tagName) { 1707 1708 switch (oNode.tagName.toUpperCase()) { 1709 1710 case sGroupTitleTagName: 1711 1712 this._aGroupTitleElements[nGroup] = oNode; 1713 1714 break; 1715 1716 case _UL_UPPERCASE: 1717 1718 this._aListElements[nGroup] = oNode; 1719 this._aItemGroups[nGroup] = []; 1720 nGroup++; 1721 1722 break; 1723 1724 } 1725 1726 } 1727 1728 } 1729 while ((oNode = oNode.nextSibling)); 1730 1731 1732 /* 1733 Apply the "first-of-type" class to the first UL to mimic 1734 the ":first-of-type" CSS3 psuedo class. 1735 */ 1736 1737 if (this._aListElements[0]) { 1738 1739 Dom.addClass(this._aListElements[0], _FIRST_OF_TYPE); 1740 1741 } 1742 1743 } 1744 1745 } 1746 1747 1748 oNode = null; 1749 1750 YAHOO.log("Searching DOM for items to initialize.", "info", this.toString()); 1751 1752 1753 if (sSrcElementTagName) { 1754 1755 switch (sSrcElementTagName) { 1756 1757 case _DIV_UPPERCASE: 1758 1759 aListElements = this._aListElements; 1760 nListElements = aListElements.length; 1761 1762 if (nListElements > 0) { 1763 1764 YAHOO.log("Found " + nListElements + " item groups to initialize.", 1765 "info", this.toString()); 1766 1767 i = nListElements - 1; 1768 1769 do { 1770 1771 oNode = aListElements[i].firstChild; 1772 1773 if (oNode) { 1774 1775 YAHOO.log("Scanning " + 1776 aListElements[i].childNodes.length + 1777 " child nodes for items to initialize.", "info", this.toString()); 1778 1779 do { 1780 1781 if (oNode && oNode.tagName && 1782 oNode.tagName.toUpperCase() == _LI) { 1783 1784 YAHOO.log("Initializing " + 1785 oNode.tagName + " node.", "info", this.toString()); 1786 1787 this.addItem(new this.ITEM_TYPE(oNode, 1788 { parent: this }), i); 1789 1790 } 1791 1792 } 1793 while ((oNode = oNode.nextSibling)); 1794 1795 } 1796 1797 } 1798 while (i--); 1799 1800 } 1801 1802 break; 1803 1804 case _SELECT: 1805 1806 YAHOO.log("Scanning " + 1807 oSrcElement.childNodes.length + 1808 " child nodes for items to initialize.", "info", this.toString()); 1809 1810 oNode = oSrcElement.firstChild; 1811 1812 do { 1813 1814 if (oNode && oNode.tagName) { 1815 1816 switch (oNode.tagName.toUpperCase()) { 1817 1818 case _OPTGROUP: 1819 case _OPTION: 1820 1821 YAHOO.log("Initializing " + 1822 oNode.tagName + " node.", "info", this.toString()); 1823 1824 this.addItem( 1825 new this.ITEM_TYPE( 1826 oNode, 1827 { parent: this } 1828 ) 1829 ); 1830 1831 break; 1832 1833 } 1834 1835 } 1836 1837 } 1838 while ((oNode = oNode.nextSibling)); 1839 1840 break; 1841 1842 } 1843 1844 } 1845 1846 } 1847 1848 }, 1849 1850 1851 /** 1852 * @method _getFirstEnabledItem 1853 * @description Returns the first enabled item in the menu. 1854 * @return {YAHOO.widget.MenuItem} 1855 * @private 1856 */ 1857 _getFirstEnabledItem: function () { 1858 1859 var aItems = this.getItems(), 1860 nItems = aItems.length, 1861 oItem, 1862 returnVal; 1863 1864 1865 for(var i=0; i<nItems; i++) { 1866 1867 oItem = aItems[i]; 1868 1869 if (oItem && !oItem.cfg.getProperty(_DISABLED) && oItem.element.style.display != _NONE) { 1870 1871 returnVal = oItem; 1872 break; 1873 1874 } 1875 1876 } 1877 1878 return returnVal; 1879 1880 }, 1881 1882 1883 /** 1884 * @method _addItemToGroup 1885 * @description Adds a menu item to a group. 1886 * @private 1887 * @param {Number} p_nGroupIndex Number indicating the group to which the 1888 * item belongs. 1889 * @param {YAHOO.widget.MenuItem} p_oItem Object reference for the MenuItem 1890 * instance to be added to the menu. 1891 * @param {HTML} p_oItem String or markup specifying the content of the item to be added 1892 * to the menu. The item is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 1893 * @param {Object} p_oItem Object literal containing a set of menu item 1894 * configuration properties. 1895 * @param {Number} p_nItemIndex Optional. Number indicating the index at 1896 * which the menu item should be added. 1897 * @return {YAHOO.widget.MenuItem} 1898 */ 1899 _addItemToGroup: function (p_nGroupIndex, p_oItem, p_nItemIndex) { 1900 1901 var oItem, 1902 nGroupIndex, 1903 aGroup, 1904 oGroupItem, 1905 bAppend, 1906 oNextItemSibling, 1907 nItemIndex, 1908 returnVal; 1909 1910 1911 function getNextItemSibling(p_aArray, p_nStartIndex) { 1912 1913 return (p_aArray[p_nStartIndex] || getNextItemSibling(p_aArray, (p_nStartIndex+1))); 1914 1915 } 1916 1917 1918 if (p_oItem instanceof this.ITEM_TYPE) { 1919 1920 oItem = p_oItem; 1921 oItem.parent = this; 1922 1923 } 1924 else if (Lang.isString(p_oItem)) { 1925 1926 oItem = new this.ITEM_TYPE(p_oItem, { parent: this }); 1927 1928 } 1929 else if (Lang.isObject(p_oItem)) { 1930 1931 p_oItem.parent = this; 1932 1933 oItem = new this.ITEM_TYPE(p_oItem.text, p_oItem); 1934 1935 } 1936 1937 1938 if (oItem) { 1939 1940 if (oItem.cfg.getProperty(_SELECTED)) { 1941 1942 this.activeItem = oItem; 1943 1944 } 1945 1946 1947 nGroupIndex = Lang.isNumber(p_nGroupIndex) ? p_nGroupIndex : 0; 1948 aGroup = this._getItemGroup(nGroupIndex); 1949 1950 1951 1952 if (!aGroup) { 1953 1954 aGroup = this._createItemGroup(nGroupIndex); 1955 1956 } 1957 1958 1959 if (Lang.isNumber(p_nItemIndex)) { 1960 1961 bAppend = (p_nItemIndex >= aGroup.length); 1962 1963 1964 if (aGroup[p_nItemIndex]) { 1965 1966 aGroup.splice(p_nItemIndex, 0, oItem); 1967 1968 } 1969 else { 1970 1971 aGroup[p_nItemIndex] = oItem; 1972 1973 } 1974 1975 1976 oGroupItem = aGroup[p_nItemIndex]; 1977 1978 if (oGroupItem) { 1979 1980 if (bAppend && (!oGroupItem.element.parentNode || 1981 oGroupItem.element.parentNode.nodeType == 11)) { 1982 1983 this._aListElements[nGroupIndex].appendChild(oGroupItem.element); 1984 1985 } 1986 else { 1987 1988 oNextItemSibling = getNextItemSibling(aGroup, (p_nItemIndex+1)); 1989 1990 if (oNextItemSibling && (!oGroupItem.element.parentNode || 1991 oGroupItem.element.parentNode.nodeType == 11)) { 1992 1993 this._aListElements[nGroupIndex].insertBefore( 1994 oGroupItem.element, oNextItemSibling.element); 1995 1996 } 1997 1998 } 1999 2000 2001 oGroupItem.parent = this; 2002 2003 this._subscribeToItemEvents(oGroupItem); 2004 2005 this._configureSubmenu(oGroupItem); 2006 2007 this._updateItemProperties(nGroupIndex); 2008 2009 YAHOO.log("Item inserted." + 2010 " Text: " + oGroupItem.cfg.getProperty("text") + ", " + 2011 " Index: " + oGroupItem.index + ", " + 2012 " Group Index: " + oGroupItem.groupIndex, "info", this.toString()); 2013 2014 this.itemAddedEvent.fire(oGroupItem); 2015 this.changeContentEvent.fire(); 2016 2017 returnVal = oGroupItem; 2018 2019 } 2020 2021 } 2022 else { 2023 2024 nItemIndex = aGroup.length; 2025 2026 aGroup[nItemIndex] = oItem; 2027 2028 oGroupItem = aGroup[nItemIndex]; 2029 2030 2031 if (oGroupItem) { 2032 2033 if (!Dom.isAncestor(this._aListElements[nGroupIndex], oGroupItem.element)) { 2034 2035 this._aListElements[nGroupIndex].appendChild(oGroupItem.element); 2036 2037 } 2038 2039 oGroupItem.element.setAttribute(_GROUP_INDEX, nGroupIndex); 2040 oGroupItem.element.setAttribute(_INDEX, nItemIndex); 2041 2042 oGroupItem.parent = this; 2043 2044 oGroupItem.index = nItemIndex; 2045 oGroupItem.groupIndex = nGroupIndex; 2046 2047 this._subscribeToItemEvents(oGroupItem); 2048 2049 this._configureSubmenu(oGroupItem); 2050 2051 if (nItemIndex === 0) { 2052 2053 Dom.addClass(oGroupItem.element, _FIRST_OF_TYPE); 2054 2055 } 2056 2057 YAHOO.log("Item added." + 2058 " Text: " + oGroupItem.cfg.getProperty("text") + ", " + 2059 " Index: " + oGroupItem.index + ", " + 2060 " Group Index: " + oGroupItem.groupIndex, "info", this.toString()); 2061 2062 2063 this.itemAddedEvent.fire(oGroupItem); 2064 this.changeContentEvent.fire(); 2065 2066 returnVal = oGroupItem; 2067 2068 } 2069 2070 } 2071 2072 } 2073 2074 return returnVal; 2075 2076 }, 2077 2078 2079 /** 2080 * @method _removeItemFromGroupByIndex 2081 * @description Removes a menu item from a group by index. Returns the menu 2082 * item that was removed. 2083 * @private 2084 * @param {Number} p_nGroupIndex Number indicating the group to which the menu 2085 * item belongs. 2086 * @param {Number} p_nItemIndex Number indicating the index of the menu item 2087 * to be removed. 2088 * @return {YAHOO.widget.MenuItem} 2089 */ 2090 _removeItemFromGroupByIndex: function (p_nGroupIndex, p_nItemIndex) { 2091 2092 var nGroupIndex = Lang.isNumber(p_nGroupIndex) ? p_nGroupIndex : 0, 2093 aGroup = this._getItemGroup(nGroupIndex), 2094 aArray, 2095 oItem, 2096 oUL; 2097 2098 if (aGroup) { 2099 2100 aArray = aGroup.splice(p_nItemIndex, 1); 2101 oItem = aArray[0]; 2102 2103 if (oItem) { 2104 2105 // Update the index and className properties of each member 2106 2107 this._updateItemProperties(nGroupIndex); 2108 2109 if (aGroup.length === 0) { 2110 2111 // Remove the UL 2112 2113 oUL = this._aListElements[nGroupIndex]; 2114 2115 if (oUL && oUL.parentNode) { 2116 oUL.parentNode.removeChild(oUL); 2117 } 2118 2119 // Remove the group from the array of items 2120 2121 this._aItemGroups.splice(nGroupIndex, 1); 2122 2123 2124 // Remove the UL from the array of ULs 2125 2126 this._aListElements.splice(nGroupIndex, 1); 2127 2128 2129 /* 2130 Assign the "first-of-type" class to the new first UL 2131 in the collection 2132 */ 2133 2134 oUL = this._aListElements[0]; 2135 2136 if (oUL) { 2137 2138 Dom.addClass(oUL, _FIRST_OF_TYPE); 2139 2140 } 2141 2142 } 2143 2144 2145 this.itemRemovedEvent.fire(oItem); 2146 this.changeContentEvent.fire(); 2147 2148 } 2149 2150 } 2151 2152 // Return a reference to the item that was removed 2153 2154 return oItem; 2155 2156 }, 2157 2158 2159 /** 2160 * @method _removeItemFromGroupByValue 2161 * @description Removes a menu item from a group by reference. Returns the 2162 * menu item that was removed. 2163 * @private 2164 * @param {Number} p_nGroupIndex Number indicating the group to which the 2165 * menu item belongs. 2166 * @param {YAHOO.widget.MenuItem} p_oItem Object reference for the MenuItem 2167 * instance to be removed. 2168 * @return {YAHOO.widget.MenuItem} 2169 */ 2170 _removeItemFromGroupByValue: function (p_nGroupIndex, p_oItem) { 2171 2172 var aGroup = this._getItemGroup(p_nGroupIndex), 2173 nItems, 2174 nItemIndex, 2175 returnVal, 2176 i; 2177 2178 if (aGroup) { 2179 2180 nItems = aGroup.length; 2181 nItemIndex = -1; 2182 2183 if (nItems > 0) { 2184 2185 i = nItems-1; 2186 2187 do { 2188 2189 if (aGroup[i] == p_oItem) { 2190 2191 nItemIndex = i; 2192 break; 2193 2194 } 2195 2196 } 2197 while (i--); 2198 2199 if (nItemIndex > -1) { 2200 2201 returnVal = this._removeItemFromGroupByIndex(p_nGroupIndex, nItemIndex); 2202 2203 } 2204 2205 } 2206 2207 } 2208 2209 return returnVal; 2210 2211 }, 2212 2213 2214 /** 2215 * @method _updateItemProperties 2216 * @description Updates the "index," "groupindex," and "className" properties 2217 * of the menu items in the specified group. 2218 * @private 2219 * @param {Number} p_nGroupIndex Number indicating the group of items to update. 2220 */ 2221 _updateItemProperties: function (p_nGroupIndex) { 2222 2223 var aGroup = this._getItemGroup(p_nGroupIndex), 2224 nItems = aGroup.length, 2225 oItem, 2226 oLI, 2227 i; 2228 2229 2230 if (nItems > 0) { 2231 2232 i = nItems - 1; 2233 2234 // Update the index and className properties of each member 2235 2236 do { 2237 2238 oItem = aGroup[i]; 2239 2240 if (oItem) { 2241 2242 oLI = oItem.element; 2243 2244 oItem.index = i; 2245 oItem.groupIndex = p_nGroupIndex; 2246 2247 oLI.setAttribute(_GROUP_INDEX, p_nGroupIndex); 2248 oLI.setAttribute(_INDEX, i); 2249 2250 Dom.removeClass(oLI, _FIRST_OF_TYPE); 2251 2252 } 2253 2254 } 2255 while (i--); 2256 2257 2258 if (oLI) { 2259 2260 Dom.addClass(oLI, _FIRST_OF_TYPE); 2261 2262 } 2263 2264 } 2265 2266 }, 2267 2268 2269 /** 2270 * @method _createItemGroup 2271 * @description Creates a new menu item group (array) and its associated 2272 * <code><ul></code> element. Returns an aray of menu item groups. 2273 * @private 2274 * @param {Number} p_nIndex Number indicating the group to create. 2275 * @return {Array} 2276 */ 2277 _createItemGroup: function (p_nIndex) { 2278 2279 var oUL, 2280 returnVal; 2281 2282 if (!this._aItemGroups[p_nIndex]) { 2283 2284 this._aItemGroups[p_nIndex] = []; 2285 2286 oUL = document.createElement(_UL_LOWERCASE); 2287 2288 this._aListElements[p_nIndex] = oUL; 2289 2290 returnVal = this._aItemGroups[p_nIndex]; 2291 2292 } 2293 2294 return returnVal; 2295 2296 }, 2297 2298 2299 /** 2300 * @method _getItemGroup 2301 * @description Returns the menu item group at the specified index. 2302 * @private 2303 * @param {Number} p_nIndex Number indicating the index of the menu item group 2304 * to be retrieved. 2305 * @return {Array} 2306 */ 2307 _getItemGroup: function (p_nIndex) { 2308 2309 var nIndex = Lang.isNumber(p_nIndex) ? p_nIndex : 0, 2310 aGroups = this._aItemGroups, 2311 returnVal; 2312 2313 if (nIndex in aGroups) { 2314 2315 returnVal = aGroups[nIndex]; 2316 2317 } 2318 2319 return returnVal; 2320 2321 }, 2322 2323 2324 /** 2325 * @method _configureSubmenu 2326 * @description Subscribes the menu item's submenu to its parent menu's events. 2327 * @private 2328 * @param {YAHOO.widget.MenuItem} p_oItem Object reference for the MenuItem 2329 * instance with the submenu to be configured. 2330 */ 2331 _configureSubmenu: function (p_oItem) { 2332 2333 var oSubmenu = p_oItem.cfg.getProperty(_SUBMENU); 2334 2335 if (oSubmenu) { 2336 2337 /* 2338 Listen for configuration changes to the parent menu 2339 so they they can be applied to the submenu. 2340 */ 2341 2342 this.cfg.configChangedEvent.subscribe(this._onParentMenuConfigChange, oSubmenu, true); 2343 2344 this.renderEvent.subscribe(this._onParentMenuRender, oSubmenu, true); 2345 2346 } 2347 2348 }, 2349 2350 2351 2352 2353 /** 2354 * @method _subscribeToItemEvents 2355 * @description Subscribes a menu to a menu item's event. 2356 * @private 2357 * @param {YAHOO.widget.MenuItem} p_oItem Object reference for the MenuItem 2358 * instance whose events should be subscribed to. 2359 */ 2360 _subscribeToItemEvents: function (p_oItem) { 2361 2362 p_oItem.destroyEvent.subscribe(this._onMenuItemDestroy, p_oItem, this); 2363 p_oItem.cfg.configChangedEvent.subscribe(this._onMenuItemConfigChange, p_oItem, this); 2364 2365 }, 2366 2367 2368 /** 2369 * @method _onVisibleChange 2370 * @description Change event handler for the the menu's "visible" configuration 2371 * property. 2372 * @private 2373 * @param {String} p_sType String representing the name of the event that 2374 * was fired. 2375 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 2376 */ 2377 _onVisibleChange: function (p_sType, p_aArgs) { 2378 2379 var bVisible = p_aArgs[0]; 2380 2381 if (bVisible) { 2382 2383 Dom.addClass(this.element, _VISIBLE); 2384 2385 } 2386 else { 2387 2388 Dom.removeClass(this.element, _VISIBLE); 2389 2390 } 2391 2392 }, 2393 2394 2395 /** 2396 * @method _cancelHideDelay 2397 * @description Cancels the call to "hideMenu." 2398 * @private 2399 */ 2400 _cancelHideDelay: function () { 2401 2402 var oTimer = this.getRoot()._hideDelayTimer; 2403 2404 if (oTimer) { 2405 2406 oTimer.cancel(); 2407 2408 } 2409 2410 }, 2411 2412 2413 /** 2414 * @method _execHideDelay 2415 * @description Hides the menu after the number of milliseconds specified by 2416 * the "hidedelay" configuration property. 2417 * @private 2418 */ 2419 _execHideDelay: function () { 2420 2421 this._cancelHideDelay(); 2422 2423 var oRoot = this.getRoot(); 2424 2425 oRoot._hideDelayTimer = Lang.later(oRoot.cfg.getProperty(_HIDE_DELAY), this, function () { 2426 2427 if (oRoot.activeItem) { 2428 if (oRoot.hasFocus()) { 2429 oRoot.activeItem.focus(); 2430 } 2431 oRoot.clearActiveItem(); 2432 } 2433 2434 if (oRoot == this && !(this instanceof YAHOO.widget.MenuBar) && 2435 this.cfg.getProperty(_POSITION) == _DYNAMIC) { 2436 this.hide(); 2437 } 2438 }); 2439 2440 }, 2441 2442 2443 /** 2444 * @method _cancelShowDelay 2445 * @description Cancels the call to the "showMenu." 2446 * @private 2447 */ 2448 _cancelShowDelay: function () { 2449 var oTimer = this.getRoot()._showDelayTimer; 2450 if (oTimer) { 2451 oTimer.cancel(); 2452 } 2453 }, 2454 2455 2456 /** 2457 * @method _execSubmenuHideDelay 2458 * @description Hides a submenu after the number of milliseconds specified by 2459 * the "submenuhidedelay" configuration property have elapsed. 2460 * @private 2461 * @param {YAHOO.widget.Menu} p_oSubmenu Object specifying the submenu that 2462 * should be hidden. 2463 * @param {Number} p_nMouseX The x coordinate of the mouse when it left 2464 * the specified submenu's parent menu item. 2465 * @param {Number} p_nHideDelay The number of milliseconds that should ellapse 2466 * before the submenu is hidden. 2467 */ 2468 _execSubmenuHideDelay: function (p_oSubmenu, p_nMouseX, p_nHideDelay) { 2469 2470 p_oSubmenu._submenuHideDelayTimer = Lang.later(50, this, function () { 2471 2472 if (this._nCurrentMouseX > (p_nMouseX + 10)) { 2473 2474 p_oSubmenu._submenuHideDelayTimer = Lang.later(p_nHideDelay, p_oSubmenu, function () { 2475 2476 this.hide(); 2477 2478 }); 2479 2480 } 2481 else { 2482 2483 p_oSubmenu.hide(); 2484 2485 } 2486 2487 }); 2488 2489 }, 2490 2491 2492 2493 // Protected methods 2494 2495 2496 /** 2497 * @method _disableScrollHeader 2498 * @description Disables the header used for scrolling the body of the menu. 2499 * @protected 2500 */ 2501 _disableScrollHeader: function () { 2502 2503 if (!this._bHeaderDisabled) { 2504 2505 Dom.addClass(this.header, _TOP_SCROLLBAR_DISABLED); 2506 this._bHeaderDisabled = true; 2507 2508 } 2509 2510 }, 2511 2512 2513 /** 2514 * @method _disableScrollFooter 2515 * @description Disables the footer used for scrolling the body of the menu. 2516 * @protected 2517 */ 2518 _disableScrollFooter: function () { 2519 2520 if (!this._bFooterDisabled) { 2521 2522 Dom.addClass(this.footer, _BOTTOM_SCROLLBAR_DISABLED); 2523 this._bFooterDisabled = true; 2524 2525 } 2526 2527 }, 2528 2529 2530 /** 2531 * @method _enableScrollHeader 2532 * @description Enables the header used for scrolling the body of the menu. 2533 * @protected 2534 */ 2535 _enableScrollHeader: function () { 2536 2537 if (this._bHeaderDisabled) { 2538 2539 Dom.removeClass(this.header, _TOP_SCROLLBAR_DISABLED); 2540 this._bHeaderDisabled = false; 2541 2542 } 2543 2544 }, 2545 2546 2547 /** 2548 * @method _enableScrollFooter 2549 * @description Enables the footer used for scrolling the body of the menu. 2550 * @protected 2551 */ 2552 _enableScrollFooter: function () { 2553 2554 if (this._bFooterDisabled) { 2555 2556 Dom.removeClass(this.footer, _BOTTOM_SCROLLBAR_DISABLED); 2557 this._bFooterDisabled = false; 2558 2559 } 2560 2561 }, 2562 2563 2564 /** 2565 * @method _onMouseOver 2566 * @description "mouseover" event handler for the menu. 2567 * @protected 2568 * @param {String} p_sType String representing the name of the event that 2569 * was fired. 2570 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 2571 */ 2572 _onMouseOver: function (p_sType, p_aArgs) { 2573 2574 var oEvent = p_aArgs[0], 2575 oItem = p_aArgs[1], 2576 oTarget = Event.getTarget(oEvent), 2577 oRoot = this.getRoot(), 2578 oSubmenuHideDelayTimer = this._submenuHideDelayTimer, 2579 oParentMenu, 2580 nShowDelay, 2581 bShowDelay, 2582 oActiveItem, 2583 oItemCfg, 2584 oSubmenu; 2585 2586 2587 var showSubmenu = function () { 2588 2589 if (this.parent.cfg.getProperty(_SELECTED)) { 2590 2591 this.show(); 2592 2593 } 2594 2595 }; 2596 2597 2598 if (!this._bStopMouseEventHandlers) { 2599 2600 if (!this._bHandledMouseOverEvent && (oTarget == this.element || 2601 Dom.isAncestor(this.element, oTarget))) { 2602 2603 // Menu mouseover logic 2604 2605 if (this._useHideDelay) { 2606 this._cancelHideDelay(); 2607 } 2608 2609 this._nCurrentMouseX = 0; 2610 2611 Event.on(this.element, _MOUSEMOVE, this._onMouseMove, this, true); 2612 2613 2614 /* 2615 If the mouse is moving from the submenu back to its corresponding menu item, 2616 don't hide the submenu or clear the active MenuItem. 2617 */ 2618 2619 if (!(oItem && Dom.isAncestor(oItem.element, Event.getRelatedTarget(oEvent)))) { 2620 2621 this.clearActiveItem(); 2622 2623 } 2624 2625 2626 if (this.parent && oSubmenuHideDelayTimer) { 2627 2628 oSubmenuHideDelayTimer.cancel(); 2629 2630 this.parent.cfg.setProperty(_SELECTED, true); 2631 2632 oParentMenu = this.parent.parent; 2633 2634 oParentMenu._bHandledMouseOutEvent = true; 2635 oParentMenu._bHandledMouseOverEvent = false; 2636 2637 } 2638 2639 2640 this._bHandledMouseOverEvent = true; 2641 this._bHandledMouseOutEvent = false; 2642 2643 } 2644 2645 2646 if (oItem && !oItem.handledMouseOverEvent && !oItem.cfg.getProperty(_DISABLED) && 2647 (oTarget == oItem.element || Dom.isAncestor(oItem.element, oTarget))) { 2648 2649 // Menu Item mouseover logic 2650 2651 nShowDelay = this.cfg.getProperty(_SHOW_DELAY); 2652 bShowDelay = (nShowDelay > 0); 2653 2654 2655 if (bShowDelay) { 2656 2657 this._cancelShowDelay(); 2658 2659 } 2660 2661 2662 oActiveItem = this.activeItem; 2663 2664 if (oActiveItem) { 2665 2666 oActiveItem.cfg.setProperty(_SELECTED, false); 2667 2668 } 2669 2670 2671 oItemCfg = oItem.cfg; 2672 2673 // Select and focus the current menu item 2674 2675 oItemCfg.setProperty(_SELECTED, true); 2676 2677 2678 if (this.hasFocus() || oRoot._hasFocus) { 2679 2680 oItem.focus(); 2681 2682 oRoot._hasFocus = false; 2683 2684 } 2685 2686 2687 if (this.cfg.getProperty(_AUTO_SUBMENU_DISPLAY)) { 2688 2689 // Show the submenu this menu item 2690 2691 oSubmenu = oItemCfg.getProperty(_SUBMENU); 2692 2693 if (oSubmenu) { 2694 2695 if (bShowDelay) { 2696 2697 oRoot._showDelayTimer = 2698 Lang.later(oRoot.cfg.getProperty(_SHOW_DELAY), oSubmenu, showSubmenu); 2699 2700 } 2701 else { 2702 2703 oSubmenu.show(); 2704 2705 } 2706 2707 } 2708 2709 } 2710 2711 oItem.handledMouseOverEvent = true; 2712 oItem.handledMouseOutEvent = false; 2713 2714 } 2715 2716 } 2717 2718 }, 2719 2720 2721 /** 2722 * @method _onMouseOut 2723 * @description "mouseout" event handler for the menu. 2724 * @protected 2725 * @param {String} p_sType String representing the name of the event that 2726 * was fired. 2727 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 2728 */ 2729 _onMouseOut: function (p_sType, p_aArgs) { 2730 2731 var oEvent = p_aArgs[0], 2732 oItem = p_aArgs[1], 2733 oRelatedTarget = Event.getRelatedTarget(oEvent), 2734 bMovingToSubmenu = false, 2735 oItemCfg, 2736 oSubmenu, 2737 nSubmenuHideDelay, 2738 nShowDelay; 2739 2740 2741 YAHOO.log("onMouseout: this == " + this); 2742 2743 if (!this._bStopMouseEventHandlers) { 2744 2745 if (oItem && !oItem.cfg.getProperty(_DISABLED)) { 2746 2747 oItemCfg = oItem.cfg; 2748 oSubmenu = oItemCfg.getProperty(_SUBMENU); 2749 2750 2751 if (oSubmenu && (oRelatedTarget == oSubmenu.element || Dom.isAncestor(oSubmenu.element, oRelatedTarget))) { 2752 bMovingToSubmenu = true; 2753 } 2754 2755 if (!oItem.handledMouseOutEvent && ((oRelatedTarget != oItem.element && !Dom.isAncestor(oItem.element, oRelatedTarget)) || bMovingToSubmenu)) { 2756 if (!bMovingToSubmenu) { 2757 oItem.cfg.setProperty(_SELECTED, false); 2758 if (oSubmenu) { 2759 2760 nSubmenuHideDelay = this.cfg.getProperty(_SUBMENU_HIDE_DELAY); 2761 nShowDelay = this.cfg.getProperty(_SHOW_DELAY); 2762 if (!(this instanceof YAHOO.widget.MenuBar) && nSubmenuHideDelay > 0 && nSubmenuHideDelay >= nShowDelay) { 2763 this._execSubmenuHideDelay(oSubmenu, Event.getPageX(oEvent), nSubmenuHideDelay); 2764 } else { 2765 oSubmenu.hide(); 2766 } 2767 } 2768 } 2769 2770 oItem.handledMouseOutEvent = true; 2771 oItem.handledMouseOverEvent = false; 2772 } 2773 } 2774 2775 YAHOO.log("onMouseout: oRelatedTarget = " + oRelatedTarget.className); 2776 YAHOO.log("onMouseout: this.element = " + this.element.id); 2777 YAHOO.log("onMouseout: Ancestorthis.element = " + Dom.isAncestor(this.element, oRelatedTarget)); 2778 YAHOO.log("onMouseout: canHide = " + this._didMouseLeave(oRelatedTarget)); 2779 2780 if (!this._bHandledMouseOutEvent) { 2781 if (this._didMouseLeave(oRelatedTarget) || bMovingToSubmenu) { 2782 // Menu mouseout logic 2783 if (this._useHideDelay) { 2784 this._execHideDelay(); 2785 } 2786 2787 Event.removeListener(this.element, _MOUSEMOVE, this._onMouseMove); 2788 2789 this._nCurrentMouseX = Event.getPageX(oEvent); 2790 2791 this._bHandledMouseOutEvent = true; 2792 this._bHandledMouseOverEvent = false; 2793 } 2794 } 2795 } 2796 2797 }, 2798 2799 /** 2800 * Utilility method to determine if we really moused out of the menu based on the related target 2801 * @method _didMouseLeave 2802 * @protected 2803 * @param {HTMLElement} oRelatedTarget The related target based on which we're making the decision 2804 * @return {boolean} true if it's OK to hide based on the related target. 2805 */ 2806 _didMouseLeave : function(oRelatedTarget) { 2807 // Hide if we're not moving back to the element from somewhere inside the element, or we're moving to an element inside the menu. 2808 // The shadow is treated as an edge case, inside inside the menu, but we get no further mouseouts, because it overflows the element, 2809 // so we need to close when moving to the menu. 2810 return (oRelatedTarget === this._shadow || (oRelatedTarget != this.element && !Dom.isAncestor(this.element, oRelatedTarget))); 2811 }, 2812 2813 /** 2814 * @method _onMouseMove 2815 * @description "click" event handler for the menu. 2816 * @protected 2817 * @param {Event} p_oEvent Object representing the DOM event object passed 2818 * back by the event utility (YAHOO.util.Event). 2819 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 2820 * fired the event. 2821 */ 2822 _onMouseMove: function (p_oEvent, p_oMenu) { 2823 2824 if (!this._bStopMouseEventHandlers) { 2825 2826 this._nCurrentMouseX = Event.getPageX(p_oEvent); 2827 2828 } 2829 2830 }, 2831 2832 2833 /** 2834 * @method _onClick 2835 * @description "click" event handler for the menu. 2836 * @protected 2837 * @param {String} p_sType String representing the name of the event that 2838 * was fired. 2839 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 2840 */ 2841 _onClick: function (p_sType, p_aArgs) { 2842 2843 var oEvent = p_aArgs[0], 2844 oItem = p_aArgs[1], 2845 bInMenuAnchor = false, 2846 oSubmenu, 2847 oMenu, 2848 oRoot, 2849 sId, 2850 sURL, 2851 nHashPos, 2852 nLen; 2853 2854 2855 var hide = function () { 2856 2857 oRoot = this.getRoot(); 2858 2859 if (oRoot instanceof YAHOO.widget.MenuBar || 2860 oRoot.cfg.getProperty(_POSITION) == _STATIC) { 2861 2862 oRoot.clearActiveItem(); 2863 2864 } 2865 else { 2866 2867 oRoot.hide(); 2868 2869 } 2870 2871 }; 2872 2873 2874 if (oItem) { 2875 2876 if (oItem.cfg.getProperty(_DISABLED)) { 2877 2878 Event.preventDefault(oEvent); 2879 2880 hide.call(this); 2881 2882 } 2883 else { 2884 2885 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 2886 2887 2888 /* 2889 Check if the URL of the anchor is pointing to an element that is 2890 a child of the menu. 2891 */ 2892 2893 sURL = oItem.cfg.getProperty(_URL); 2894 2895 2896 if (sURL) { 2897 2898 nHashPos = sURL.indexOf(_HASH); 2899 2900 nLen = sURL.length; 2901 2902 2903 if (nHashPos != -1) { 2904 2905 sURL = sURL.substr(nHashPos, nLen); 2906 2907 nLen = sURL.length; 2908 2909 2910 if (nLen > 1) { 2911 2912 sId = sURL.substr(1, nLen); 2913 2914 oMenu = YAHOO.widget.MenuManager.getMenu(sId); 2915 2916 if (oMenu) { 2917 2918 bInMenuAnchor = 2919 (this.getRoot() === oMenu.getRoot()); 2920 2921 } 2922 2923 } 2924 else if (nLen === 1) { 2925 2926 bInMenuAnchor = true; 2927 2928 } 2929 2930 } 2931 2932 } 2933 2934 2935 if (bInMenuAnchor && !oItem.cfg.getProperty(_TARGET)) { 2936 2937 Event.preventDefault(oEvent); 2938 2939 2940 if (UA.webkit) { 2941 2942 oItem.focus(); 2943 2944 } 2945 else { 2946 2947 oItem.focusEvent.fire(); 2948 2949 } 2950 2951 } 2952 2953 2954 if (!oSubmenu && !this.cfg.getProperty(_KEEP_OPEN)) { 2955 2956 hide.call(this); 2957 2958 } 2959 2960 } 2961 2962 } 2963 2964 }, 2965 2966 /* 2967 This function is called to prevent a bug in Firefox. In Firefox, 2968 moving a DOM element into a stationary mouse pointer will cause the 2969 browser to fire mouse events. This can result in the menu mouse 2970 event handlers being called uncessarily, especially when menus are 2971 moved into a stationary mouse pointer as a result of a 2972 key event handler. 2973 */ 2974 /** 2975 * Utility method to stop mouseevents from being fired if the DOM 2976 * changes under a stationary mouse pointer (as opposed to the mouse moving 2977 * over a DOM element). 2978 * 2979 * @method _stopMouseEventHandlers 2980 * @private 2981 */ 2982 _stopMouseEventHandlers: function() { 2983 this._bStopMouseEventHandlers = true; 2984 2985 Lang.later(10, this, function () { 2986 this._bStopMouseEventHandlers = false; 2987 }); 2988 }, 2989 2990 /** 2991 * @method _onKeyDown 2992 * @description "keydown" event handler for the menu. 2993 * @protected 2994 * @param {String} p_sType String representing the name of the event that 2995 * was fired. 2996 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 2997 */ 2998 _onKeyDown: function (p_sType, p_aArgs) { 2999 3000 var oEvent = p_aArgs[0], 3001 oItem = p_aArgs[1], 3002 oSubmenu, 3003 oItemCfg, 3004 oParentItem, 3005 oRoot, 3006 oNextItem, 3007 oBody, 3008 nBodyScrollTop, 3009 nBodyOffsetHeight, 3010 aItems, 3011 nItems, 3012 nNextItemOffsetTop, 3013 nScrollTarget, 3014 oParentMenu, 3015 oFocusedEl; 3016 3017 3018 if (this._useHideDelay) { 3019 this._cancelHideDelay(); 3020 } 3021 3022 if (oItem && !oItem.cfg.getProperty(_DISABLED)) { 3023 3024 oItemCfg = oItem.cfg; 3025 oParentItem = this.parent; 3026 3027 switch(oEvent.keyCode) { 3028 3029 case 38: // Up arrow 3030 case 40: // Down arrow 3031 3032 oNextItem = (oEvent.keyCode == 38) ? 3033 oItem.getPreviousEnabledSibling() : 3034 oItem.getNextEnabledSibling(); 3035 3036 if (oNextItem) { 3037 3038 this.clearActiveItem(); 3039 3040 oNextItem.cfg.setProperty(_SELECTED, true); 3041 oNextItem.focus(); 3042 3043 if (this.cfg.getProperty(_MAX_HEIGHT) > 0 || Dom.hasClass(this.body, _YUI_MENU_BODY_SCROLLED)) { 3044 3045 oBody = this.body; 3046 nBodyScrollTop = oBody.scrollTop; 3047 nBodyOffsetHeight = oBody.offsetHeight; 3048 aItems = this.getItems(); 3049 nItems = aItems.length - 1; 3050 nNextItemOffsetTop = oNextItem.element.offsetTop; 3051 3052 3053 if (oEvent.keyCode == 40 ) { // Down 3054 3055 if (nNextItemOffsetTop >= (nBodyOffsetHeight + nBodyScrollTop)) { 3056 3057 oBody.scrollTop = nNextItemOffsetTop - nBodyOffsetHeight; 3058 3059 } 3060 else if (nNextItemOffsetTop <= nBodyScrollTop) { 3061 3062 oBody.scrollTop = 0; 3063 3064 } 3065 3066 3067 if (oNextItem == aItems[nItems]) { 3068 3069 oBody.scrollTop = oNextItem.element.offsetTop; 3070 3071 } 3072 3073 } 3074 else { // Up 3075 3076 if (nNextItemOffsetTop <= nBodyScrollTop) { 3077 3078 oBody.scrollTop = nNextItemOffsetTop - oNextItem.element.offsetHeight; 3079 3080 } 3081 else if (nNextItemOffsetTop >= (nBodyScrollTop + nBodyOffsetHeight)) { 3082 3083 oBody.scrollTop = nNextItemOffsetTop; 3084 3085 } 3086 3087 3088 if (oNextItem == aItems[0]) { 3089 3090 oBody.scrollTop = 0; 3091 3092 } 3093 3094 } 3095 3096 3097 nBodyScrollTop = oBody.scrollTop; 3098 nScrollTarget = oBody.scrollHeight - oBody.offsetHeight; 3099 3100 if (nBodyScrollTop === 0) { 3101 3102 this._disableScrollHeader(); 3103 this._enableScrollFooter(); 3104 3105 } 3106 else if (nBodyScrollTop == nScrollTarget) { 3107 3108 this._enableScrollHeader(); 3109 this._disableScrollFooter(); 3110 3111 } 3112 else { 3113 3114 this._enableScrollHeader(); 3115 this._enableScrollFooter(); 3116 3117 } 3118 3119 } 3120 3121 } 3122 3123 3124 Event.preventDefault(oEvent); 3125 3126 this._stopMouseEventHandlers(); 3127 3128 break; 3129 3130 3131 case 39: // Right arrow 3132 3133 oSubmenu = oItemCfg.getProperty(_SUBMENU); 3134 3135 if (oSubmenu) { 3136 3137 if (!oItemCfg.getProperty(_SELECTED)) { 3138 3139 oItemCfg.setProperty(_SELECTED, true); 3140 3141 } 3142 3143 oSubmenu.show(); 3144 oSubmenu.setInitialFocus(); 3145 oSubmenu.setInitialSelection(); 3146 3147 } 3148 else { 3149 3150 oRoot = this.getRoot(); 3151 3152 if (oRoot instanceof YAHOO.widget.MenuBar) { 3153 3154 oNextItem = oRoot.activeItem.getNextEnabledSibling(); 3155 3156 if (oNextItem) { 3157 3158 oRoot.clearActiveItem(); 3159 3160 oNextItem.cfg.setProperty(_SELECTED, true); 3161 3162 oSubmenu = oNextItem.cfg.getProperty(_SUBMENU); 3163 3164 if (oSubmenu) { 3165 3166 oSubmenu.show(); 3167 oSubmenu.setInitialFocus(); 3168 3169 } 3170 else { 3171 3172 oNextItem.focus(); 3173 3174 } 3175 3176 } 3177 3178 } 3179 3180 } 3181 3182 3183 Event.preventDefault(oEvent); 3184 3185 this._stopMouseEventHandlers(); 3186 3187 break; 3188 3189 3190 case 37: // Left arrow 3191 3192 if (oParentItem) { 3193 3194 oParentMenu = oParentItem.parent; 3195 3196 if (oParentMenu instanceof YAHOO.widget.MenuBar) { 3197 3198 oNextItem = 3199 oParentMenu.activeItem.getPreviousEnabledSibling(); 3200 3201 if (oNextItem) { 3202 3203 oParentMenu.clearActiveItem(); 3204 3205 oNextItem.cfg.setProperty(_SELECTED, true); 3206 3207 oSubmenu = oNextItem.cfg.getProperty(_SUBMENU); 3208 3209 if (oSubmenu) { 3210 3211 oSubmenu.show(); 3212 oSubmenu.setInitialFocus(); 3213 3214 } 3215 else { 3216 3217 oNextItem.focus(); 3218 3219 } 3220 3221 } 3222 3223 } 3224 else { 3225 3226 this.hide(); 3227 3228 oParentItem.focus(); 3229 3230 } 3231 3232 } 3233 3234 Event.preventDefault(oEvent); 3235 3236 this._stopMouseEventHandlers(); 3237 3238 break; 3239 3240 } 3241 3242 3243 } 3244 3245 3246 if (oEvent.keyCode == 27) { // Esc key 3247 3248 if (this.cfg.getProperty(_POSITION) == _DYNAMIC) { 3249 3250 this.hide(); 3251 3252 if (this.parent) { 3253 3254 this.parent.focus(); 3255 3256 } 3257 else { 3258 // Focus the element that previously had focus 3259 3260 oFocusedEl = this._focusedElement; 3261 3262 if (oFocusedEl && oFocusedEl.focus) { 3263 3264 try { 3265 oFocusedEl.focus(); 3266 } 3267 catch(ex) { 3268 } 3269 3270 } 3271 3272 } 3273 3274 } 3275 else if (this.activeItem) { 3276 3277 oSubmenu = this.activeItem.cfg.getProperty(_SUBMENU); 3278 3279 if (oSubmenu && oSubmenu.cfg.getProperty(_VISIBLE)) { 3280 3281 oSubmenu.hide(); 3282 this.activeItem.focus(); 3283 3284 } 3285 else { 3286 3287 this.activeItem.blur(); 3288 this.activeItem.cfg.setProperty(_SELECTED, false); 3289 3290 } 3291 3292 } 3293 3294 3295 Event.preventDefault(oEvent); 3296 3297 } 3298 3299 }, 3300 3301 3302 /** 3303 * @method _onKeyPress 3304 * @description "keypress" event handler for a Menu instance. 3305 * @protected 3306 * @param {String} p_sType The name of the event that was fired. 3307 * @param {Array} p_aArgs Collection of arguments sent when the event 3308 * was fired. 3309 */ 3310 _onKeyPress: function (p_sType, p_aArgs) { 3311 3312 var oEvent = p_aArgs[0]; 3313 3314 3315 if (oEvent.keyCode == 40 || oEvent.keyCode == 38) { 3316 3317 Event.preventDefault(oEvent); 3318 3319 } 3320 3321 }, 3322 3323 3324 /** 3325 * @method _onBlur 3326 * @description "blur" event handler for a Menu instance. 3327 * @protected 3328 * @param {String} p_sType The name of the event that was fired. 3329 * @param {Array} p_aArgs Collection of arguments sent when the event 3330 * was fired. 3331 */ 3332 _onBlur: function (p_sType, p_aArgs) { 3333 3334 if (this._hasFocus) { 3335 this._hasFocus = false; 3336 } 3337 3338 }, 3339 3340 /** 3341 * @method _onYChange 3342 * @description "y" event handler for a Menu instance. 3343 * @protected 3344 * @param {String} p_sType The name of the event that was fired. 3345 * @param {Array} p_aArgs Collection of arguments sent when the event 3346 * was fired. 3347 */ 3348 _onYChange: function (p_sType, p_aArgs) { 3349 3350 var oParent = this.parent, 3351 nScrollTop, 3352 oIFrame, 3353 nY; 3354 3355 3356 if (oParent) { 3357 3358 nScrollTop = oParent.parent.body.scrollTop; 3359 3360 3361 if (nScrollTop > 0) { 3362 3363 nY = (this.cfg.getProperty(_Y) - nScrollTop); 3364 3365 Dom.setY(this.element, nY); 3366 3367 oIFrame = this.iframe; 3368 3369 3370 if (oIFrame) { 3371 3372 Dom.setY(oIFrame, nY); 3373 3374 } 3375 3376 this.cfg.setProperty(_Y, nY, true); 3377 3378 } 3379 3380 } 3381 3382 }, 3383 3384 3385 /** 3386 * @method _onScrollTargetMouseOver 3387 * @description "mouseover" event handler for the menu's "header" and "footer" 3388 * elements. Used to scroll the body of the menu up and down when the 3389 * menu's "maxheight" configuration property is set to a value greater than 0. 3390 * @protected 3391 * @param {Event} p_oEvent Object representing the DOM event object passed 3392 * back by the event utility (YAHOO.util.Event). 3393 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 3394 * fired the event. 3395 */ 3396 _onScrollTargetMouseOver: function (p_oEvent, p_oMenu) { 3397 3398 var oBodyScrollTimer = this._bodyScrollTimer; 3399 3400 3401 if (oBodyScrollTimer) { 3402 3403 oBodyScrollTimer.cancel(); 3404 3405 } 3406 3407 3408 this._cancelHideDelay(); 3409 3410 3411 var oTarget = Event.getTarget(p_oEvent), 3412 oBody = this.body, 3413 nScrollIncrement = this.cfg.getProperty(_SCROLL_INCREMENT), 3414 nScrollTarget, 3415 fnScrollFunction; 3416 3417 3418 function scrollBodyDown() { 3419 3420 var nScrollTop = oBody.scrollTop; 3421 3422 3423 if (nScrollTop < nScrollTarget) { 3424 3425 oBody.scrollTop = (nScrollTop + nScrollIncrement); 3426 3427 this._enableScrollHeader(); 3428 3429 } 3430 else { 3431 3432 oBody.scrollTop = nScrollTarget; 3433 3434 this._bodyScrollTimer.cancel(); 3435 3436 this._disableScrollFooter(); 3437 3438 } 3439 3440 } 3441 3442 3443 function scrollBodyUp() { 3444 3445 var nScrollTop = oBody.scrollTop; 3446 3447 3448 if (nScrollTop > 0) { 3449 3450 oBody.scrollTop = (nScrollTop - nScrollIncrement); 3451 3452 this._enableScrollFooter(); 3453 3454 } 3455 else { 3456 3457 oBody.scrollTop = 0; 3458 3459 this._bodyScrollTimer.cancel(); 3460 3461 this._disableScrollHeader(); 3462 3463 } 3464 3465 } 3466 3467 3468 if (Dom.hasClass(oTarget, _HD)) { 3469 3470 fnScrollFunction = scrollBodyUp; 3471 3472 } 3473 else { 3474 3475 nScrollTarget = oBody.scrollHeight - oBody.offsetHeight; 3476 3477 fnScrollFunction = scrollBodyDown; 3478 3479 } 3480 3481 3482 this._bodyScrollTimer = Lang.later(10, this, fnScrollFunction, null, true); 3483 3484 }, 3485 3486 3487 /** 3488 * @method _onScrollTargetMouseOut 3489 * @description "mouseout" event handler for the menu's "header" and "footer" 3490 * elements. Used to stop scrolling the body of the menu up and down when the 3491 * menu's "maxheight" configuration property is set to a value greater than 0. 3492 * @protected 3493 * @param {Event} p_oEvent Object representing the DOM event object passed 3494 * back by the event utility (YAHOO.util.Event). 3495 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 3496 * fired the event. 3497 */ 3498 _onScrollTargetMouseOut: function (p_oEvent, p_oMenu) { 3499 3500 var oBodyScrollTimer = this._bodyScrollTimer; 3501 3502 if (oBodyScrollTimer) { 3503 3504 oBodyScrollTimer.cancel(); 3505 3506 } 3507 3508 this._cancelHideDelay(); 3509 3510 }, 3511 3512 3513 3514 // Private methods 3515 3516 3517 /** 3518 * @method _onInit 3519 * @description "init" event handler for the menu. 3520 * @private 3521 * @param {String} p_sType String representing the name of the event that 3522 * was fired. 3523 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 3524 */ 3525 _onInit: function (p_sType, p_aArgs) { 3526 3527 this.cfg.subscribeToConfigEvent(_VISIBLE, this._onVisibleChange); 3528 3529 var bRootMenu = !this.parent, 3530 bLazyLoad = this.lazyLoad; 3531 3532 3533 /* 3534 Automatically initialize a menu's subtree if: 3535 3536 1) This is the root menu and lazyload is off 3537 3538 2) This is the root menu, lazyload is on, but the menu is 3539 already visible 3540 3541 3) This menu is a submenu and lazyload is off 3542 */ 3543 3544 3545 3546 if (((bRootMenu && !bLazyLoad) || 3547 (bRootMenu && (this.cfg.getProperty(_VISIBLE) || 3548 this.cfg.getProperty(_POSITION) == _STATIC)) || 3549 (!bRootMenu && !bLazyLoad)) && this.getItemGroups().length === 0) { 3550 3551 if (this.srcElement) { 3552 3553 this._initSubTree(); 3554 3555 } 3556 3557 3558 if (this.itemData) { 3559 3560 this.addItems(this.itemData); 3561 3562 } 3563 3564 } 3565 else if (bLazyLoad) { 3566 3567 this.cfg.fireQueue(); 3568 3569 } 3570 3571 }, 3572 3573 3574 /** 3575 * @method _onBeforeRender 3576 * @description "beforerender" event handler for the menu. Appends all of the 3577 * <code><ul></code>, <code><li></code> and their accompanying 3578 * title elements to the body element of the menu. 3579 * @private 3580 * @param {String} p_sType String representing the name of the event that 3581 * was fired. 3582 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 3583 */ 3584 _onBeforeRender: function (p_sType, p_aArgs) { 3585 3586 var oEl = this.element, 3587 nListElements = this._aListElements.length, 3588 bFirstList = true, 3589 i = 0, 3590 oUL, 3591 oGroupTitle; 3592 3593 if (nListElements > 0) { 3594 3595 do { 3596 3597 oUL = this._aListElements[i]; 3598 3599 if (oUL) { 3600 3601 if (bFirstList) { 3602 3603 Dom.addClass(oUL, _FIRST_OF_TYPE); 3604 bFirstList = false; 3605 3606 } 3607 3608 3609 if (!Dom.isAncestor(oEl, oUL)) { 3610 3611 this.appendToBody(oUL); 3612 3613 } 3614 3615 3616 oGroupTitle = this._aGroupTitleElements[i]; 3617 3618 if (oGroupTitle) { 3619 3620 if (!Dom.isAncestor(oEl, oGroupTitle)) { 3621 3622 oUL.parentNode.insertBefore(oGroupTitle, oUL); 3623 3624 } 3625 3626 3627 Dom.addClass(oUL, _HAS_TITLE); 3628 3629 } 3630 3631 } 3632 3633 i++; 3634 3635 } 3636 while (i < nListElements); 3637 3638 } 3639 3640 }, 3641 3642 3643 /** 3644 * @method _onRender 3645 * @description "render" event handler for the menu. 3646 * @private 3647 * @param {String} p_sType String representing the name of the event that 3648 * was fired. 3649 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 3650 */ 3651 _onRender: function (p_sType, p_aArgs) { 3652 3653 if (this.cfg.getProperty(_POSITION) == _DYNAMIC) { 3654 3655 if (!this.cfg.getProperty(_VISIBLE)) { 3656 3657 this.positionOffScreen(); 3658 3659 } 3660 3661 } 3662 3663 }, 3664 3665 3666 3667 3668 3669 /** 3670 * @method _onBeforeShow 3671 * @description "beforeshow" event handler for the menu. 3672 * @private 3673 * @param {String} p_sType String representing the name of the event that 3674 * was fired. 3675 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 3676 */ 3677 _onBeforeShow: function (p_sType, p_aArgs) { 3678 3679 var nOptions, 3680 n, 3681 oSrcElement, 3682 oContainer = this.cfg.getProperty(_CONTAINER); 3683 3684 3685 if (this.lazyLoad && this.getItemGroups().length === 0) { 3686 3687 if (this.srcElement) { 3688 3689 this._initSubTree(); 3690 3691 } 3692 3693 3694 if (this.itemData) { 3695 3696 if (this.parent && this.parent.parent && 3697 this.parent.parent.srcElement && 3698 this.parent.parent.srcElement.tagName.toUpperCase() == 3699 _SELECT) { 3700 3701 nOptions = this.itemData.length; 3702 3703 for(n=0; n<nOptions; n++) { 3704 3705 if (this.itemData[n].tagName) { 3706 3707 this.addItem((new this.ITEM_TYPE(this.itemData[n]))); 3708 3709 } 3710 3711 } 3712 3713 } 3714 else { 3715 3716 this.addItems(this.itemData); 3717 3718 } 3719 3720 } 3721 3722 3723 oSrcElement = this.srcElement; 3724 3725 if (oSrcElement) { 3726 3727 if (oSrcElement.tagName.toUpperCase() == _SELECT) { 3728 3729 if (Dom.inDocument(oSrcElement)) { 3730 3731 this.render(oSrcElement.parentNode); 3732 3733 } 3734 else { 3735 3736 this.render(oContainer); 3737 3738 } 3739 3740 } 3741 else { 3742 3743 this.render(); 3744 3745 } 3746 3747 } 3748 else { 3749 3750 if (this.parent) { 3751 3752 this.render(this.parent.element); 3753 3754 } 3755 else { 3756 3757 this.render(oContainer); 3758 3759 } 3760 3761 } 3762 3763 } 3764 3765 3766 3767 var oParent = this.parent, 3768 aAlignment; 3769 3770 3771 if (!oParent && this.cfg.getProperty(_POSITION) == _DYNAMIC) { 3772 3773 this.cfg.refireEvent(_XY); 3774 3775 } 3776 3777 3778 if (oParent) { 3779 3780 aAlignment = oParent.parent.cfg.getProperty(_SUBMENU_ALIGNMENT); 3781 3782 this.cfg.setProperty(_CONTEXT, [oParent.element, aAlignment[0], aAlignment[1]]); 3783 this.align(); 3784 3785 } 3786 3787 }, 3788 3789 3790 getConstrainedY: function (y) { 3791 3792 var oMenu = this, 3793 3794 aContext = oMenu.cfg.getProperty(_CONTEXT), 3795 nInitialMaxHeight = oMenu.cfg.getProperty(_MAX_HEIGHT), 3796 3797 nMaxHeight, 3798 3799 oOverlapPositions = { 3800 3801 "trbr": true, 3802 "tlbl": true, 3803 "bltl": true, 3804 "brtr": true 3805 3806 }, 3807 3808 bPotentialContextOverlap = (aContext && oOverlapPositions[aContext[1] + aContext[2]]), 3809 3810 oMenuEl = oMenu.element, 3811 nMenuOffsetHeight = oMenuEl.offsetHeight, 3812 3813 nViewportOffset = Overlay.VIEWPORT_OFFSET, 3814 viewPortHeight = Dom.getViewportHeight(), 3815 scrollY = Dom.getDocumentScrollTop(), 3816 3817 bCanConstrain = 3818 (oMenu.cfg.getProperty(_MIN_SCROLL_HEIGHT) + nViewportOffset < viewPortHeight), 3819 3820 nAvailableHeight, 3821 3822 oContextEl, 3823 nContextElY, 3824 nContextElHeight, 3825 3826 bFlipped = false, 3827 3828 nTopRegionHeight, 3829 nBottomRegionHeight, 3830 3831 topConstraint = scrollY + nViewportOffset, 3832 bottomConstraint = scrollY + viewPortHeight - nMenuOffsetHeight - nViewportOffset, 3833 3834 yNew = y; 3835 3836 3837 var flipVertical = function () { 3838 3839 var nNewY; 3840 3841 // The Menu is below the context element, flip it above 3842 if ((oMenu.cfg.getProperty(_Y) - scrollY) > nContextElY) { 3843 nNewY = (nContextElY - nMenuOffsetHeight); 3844 } 3845 else { // The Menu is above the context element, flip it below 3846 nNewY = (nContextElY + nContextElHeight); 3847 } 3848 3849 oMenu.cfg.setProperty(_Y, (nNewY + scrollY), true); 3850 3851 return nNewY; 3852 3853 }; 3854 3855 3856 /* 3857 Uses the context element's position to calculate the availble height 3858 above and below it to display its corresponding Menu. 3859 */ 3860 3861 var getDisplayRegionHeight = function () { 3862 3863 // The Menu is below the context element 3864 if ((oMenu.cfg.getProperty(_Y) - scrollY) > nContextElY) { 3865 return (nBottomRegionHeight - nViewportOffset); 3866 } 3867 else { // The Menu is above the context element 3868 return (nTopRegionHeight - nViewportOffset); 3869 } 3870 3871 }; 3872 3873 3874 /* 3875 Sets the Menu's "y" configuration property to the correct value based on its 3876 current orientation. 3877 */ 3878 3879 var alignY = function () { 3880 3881 var nNewY; 3882 3883 if ((oMenu.cfg.getProperty(_Y) - scrollY) > nContextElY) { 3884 nNewY = (nContextElY + nContextElHeight); 3885 } 3886 else { 3887 nNewY = (nContextElY - oMenuEl.offsetHeight); 3888 } 3889 3890 oMenu.cfg.setProperty(_Y, (nNewY + scrollY), true); 3891 3892 }; 3893 3894 3895 // Resets the maxheight of the Menu to the value set by the user 3896 3897 var resetMaxHeight = function () { 3898 3899 oMenu._setScrollHeight(this.cfg.getProperty(_MAX_HEIGHT)); 3900 3901 oMenu.hideEvent.unsubscribe(resetMaxHeight); 3902 3903 }; 3904 3905 3906 /* 3907 Trys to place the Menu in the best possible position (either above or 3908 below its corresponding context element). 3909 */ 3910 3911 var setVerticalPosition = function () { 3912 3913 var nDisplayRegionHeight = getDisplayRegionHeight(), 3914 bMenuHasItems = (oMenu.getItems().length > 0), 3915 nMenuMinScrollHeight, 3916 fnReturnVal; 3917 3918 3919 if (nMenuOffsetHeight > nDisplayRegionHeight) { 3920 3921 nMenuMinScrollHeight = 3922 bMenuHasItems ? oMenu.cfg.getProperty(_MIN_SCROLL_HEIGHT) : nMenuOffsetHeight; 3923 3924 3925 if ((nDisplayRegionHeight > nMenuMinScrollHeight) && bMenuHasItems) { 3926 nMaxHeight = nDisplayRegionHeight; 3927 } 3928 else { 3929 nMaxHeight = nInitialMaxHeight; 3930 } 3931 3932 3933 oMenu._setScrollHeight(nMaxHeight); 3934 oMenu.hideEvent.subscribe(resetMaxHeight); 3935 3936 3937 // Re-align the Menu since its height has just changed 3938 // as a result of the setting of the maxheight property. 3939 3940 alignY(); 3941 3942 3943 if (nDisplayRegionHeight < nMenuMinScrollHeight) { 3944 3945 if (bFlipped) { 3946 3947 /* 3948 All possible positions and values for the "maxheight" 3949 configuration property have been tried, but none were 3950 successful, so fall back to the original size and position. 3951 */ 3952 3953 flipVertical(); 3954 3955 } 3956 else { 3957 3958 flipVertical(); 3959 3960 bFlipped = true; 3961 3962 fnReturnVal = setVerticalPosition(); 3963 3964 } 3965 3966 } 3967 3968 } 3969 else if (nMaxHeight && (nMaxHeight !== nInitialMaxHeight)) { 3970 3971 oMenu._setScrollHeight(nInitialMaxHeight); 3972 oMenu.hideEvent.subscribe(resetMaxHeight); 3973 3974 // Re-align the Menu since its height has just changed 3975 // as a result of the setting of the maxheight property. 3976 3977 alignY(); 3978 3979 } 3980 3981 return fnReturnVal; 3982 3983 }; 3984 3985 3986 // Determine if the current value for the Menu's "y" configuration property will 3987 // result in the Menu being positioned outside the boundaries of the viewport 3988 3989 if (y < topConstraint || y > bottomConstraint) { 3990 3991 // The current value for the Menu's "y" configuration property WILL 3992 // result in the Menu being positioned outside the boundaries of the viewport 3993 3994 if (bCanConstrain) { 3995 3996 if (oMenu.cfg.getProperty(_PREVENT_CONTEXT_OVERLAP) && bPotentialContextOverlap) { 3997 3998 // SOLUTION #1: 3999 // If the "preventcontextoverlap" configuration property is set to "true", 4000 // try to flip and/or scroll the Menu to both keep it inside the boundaries of the 4001 // viewport AND from overlaping its context element (MenuItem or MenuBarItem). 4002 4003 oContextEl = aContext[0]; 4004 nContextElHeight = oContextEl.offsetHeight; 4005 nContextElY = (Dom.getY(oContextEl) - scrollY); 4006 4007 nTopRegionHeight = nContextElY; 4008 nBottomRegionHeight = (viewPortHeight - (nContextElY + nContextElHeight)); 4009 4010 setVerticalPosition(); 4011 4012 yNew = oMenu.cfg.getProperty(_Y); 4013 4014 } 4015 else if (!(oMenu instanceof YAHOO.widget.MenuBar) && 4016 nMenuOffsetHeight >= viewPortHeight) { 4017 4018 // SOLUTION #2: 4019 // If the Menu exceeds the height of the viewport, introduce scroll bars 4020 // to keep the Menu inside the boundaries of the viewport 4021 4022 nAvailableHeight = (viewPortHeight - (nViewportOffset * 2)); 4023 4024 if (nAvailableHeight > oMenu.cfg.getProperty(_MIN_SCROLL_HEIGHT)) { 4025 4026 oMenu._setScrollHeight(nAvailableHeight); 4027 oMenu.hideEvent.subscribe(resetMaxHeight); 4028 4029 alignY(); 4030 4031 yNew = oMenu.cfg.getProperty(_Y); 4032 4033 } 4034 4035 } 4036 else { 4037 4038 // SOLUTION #3: 4039 4040 if (y < topConstraint) { 4041 yNew = topConstraint; 4042 } else if (y > bottomConstraint) { 4043 yNew = bottomConstraint; 4044 } 4045 4046 } 4047 4048 } 4049 else { 4050 // The "y" configuration property cannot be set to a value that will keep 4051 // entire Menu inside the boundary of the viewport. Therefore, set 4052 // the "y" configuration property to scrollY to keep as much of the 4053 // Menu inside the viewport as possible. 4054 yNew = nViewportOffset + scrollY; 4055 } 4056 4057 } 4058 4059 return yNew; 4060 4061 }, 4062 4063 4064 /** 4065 * @method _onHide 4066 * @description "hide" event handler for the menu. 4067 * @private 4068 * @param {String} p_sType String representing the name of the event that 4069 * was fired. 4070 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4071 */ 4072 _onHide: function (p_sType, p_aArgs) { 4073 4074 if (this.cfg.getProperty(_POSITION) === _DYNAMIC) { 4075 4076 this.positionOffScreen(); 4077 4078 } 4079 4080 }, 4081 4082 4083 /** 4084 * @method _onShow 4085 * @description "show" event handler for the menu. 4086 * @private 4087 * @param {String} p_sType String representing the name of the event that 4088 * was fired. 4089 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4090 */ 4091 _onShow: function (p_sType, p_aArgs) { 4092 4093 var oParent = this.parent, 4094 oParentMenu, 4095 oElement, 4096 nOffsetWidth, 4097 sWidth; 4098 4099 4100 function disableAutoSubmenuDisplay(p_oEvent) { 4101 4102 var oTarget; 4103 4104 if (p_oEvent.type == _MOUSEDOWN || (p_oEvent.type == _KEYDOWN && p_oEvent.keyCode == 27)) { 4105 4106 /* 4107 Set the "autosubmenudisplay" to "false" if the user 4108 clicks outside the menu bar. 4109 */ 4110 4111 oTarget = Event.getTarget(p_oEvent); 4112 4113 if (oTarget != oParentMenu.element || !Dom.isAncestor(oParentMenu.element, oTarget)) { 4114 4115 oParentMenu.cfg.setProperty(_AUTO_SUBMENU_DISPLAY, false); 4116 4117 Event.removeListener(document, _MOUSEDOWN, disableAutoSubmenuDisplay); 4118 Event.removeListener(document, _KEYDOWN, disableAutoSubmenuDisplay); 4119 4120 } 4121 4122 } 4123 4124 } 4125 4126 4127 function onSubmenuHide(p_sType, p_aArgs, p_sWidth) { 4128 4129 this.cfg.setProperty(_WIDTH, _EMPTY_STRING); 4130 this.hideEvent.unsubscribe(onSubmenuHide, p_sWidth); 4131 4132 } 4133 4134 4135 if (oParent) { 4136 4137 oParentMenu = oParent.parent; 4138 4139 4140 if (!oParentMenu.cfg.getProperty(_AUTO_SUBMENU_DISPLAY) && 4141 (oParentMenu instanceof YAHOO.widget.MenuBar || 4142 oParentMenu.cfg.getProperty(_POSITION) == _STATIC)) { 4143 4144 oParentMenu.cfg.setProperty(_AUTO_SUBMENU_DISPLAY, true); 4145 4146 Event.on(document, _MOUSEDOWN, disableAutoSubmenuDisplay); 4147 Event.on(document, _KEYDOWN, disableAutoSubmenuDisplay); 4148 4149 } 4150 4151 4152 // The following fixes an issue with the selected state of a MenuItem 4153 // not rendering correctly when a submenu is aligned to the left of 4154 // its parent Menu instance. 4155 4156 if ((this.cfg.getProperty("x") < oParentMenu.cfg.getProperty("x")) && 4157 (UA.gecko && UA.gecko < 1.9) && !this.cfg.getProperty(_WIDTH)) { 4158 4159 oElement = this.element; 4160 nOffsetWidth = oElement.offsetWidth; 4161 4162 /* 4163 Measuring the difference of the offsetWidth before and after 4164 setting the "width" style attribute allows us to compute the 4165 about of padding and borders applied to the element, which in 4166 turn allows us to set the "width" property correctly. 4167 */ 4168 4169 oElement.style.width = nOffsetWidth + _PX; 4170 4171 sWidth = (nOffsetWidth - (oElement.offsetWidth - nOffsetWidth)) + _PX; 4172 4173 this.cfg.setProperty(_WIDTH, sWidth); 4174 4175 this.hideEvent.subscribe(onSubmenuHide, sWidth); 4176 4177 } 4178 4179 } 4180 4181 4182 /* 4183 Dynamically positioned, root Menus focus themselves when visible, and 4184 will then, when hidden, restore focus to the UI control that had focus 4185 before the Menu was made visible. 4186 */ 4187 4188 if (this === this.getRoot() && this.cfg.getProperty(_POSITION) === _DYNAMIC) { 4189 4190 this._focusedElement = oFocusedElement; 4191 4192 this.focus(); 4193 4194 } 4195 4196 4197 }, 4198 4199 4200 /** 4201 * @method _onBeforeHide 4202 * @description "beforehide" event handler for the menu. 4203 * @private 4204 * @param {String} p_sType String representing the name of the event that 4205 * was fired. 4206 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4207 */ 4208 _onBeforeHide: function (p_sType, p_aArgs) { 4209 4210 var oActiveItem = this.activeItem, 4211 oRoot = this.getRoot(), 4212 oConfig, 4213 oSubmenu; 4214 4215 4216 if (oActiveItem) { 4217 4218 oConfig = oActiveItem.cfg; 4219 4220 oConfig.setProperty(_SELECTED, false); 4221 4222 oSubmenu = oConfig.getProperty(_SUBMENU); 4223 4224 if (oSubmenu) { 4225 4226 oSubmenu.hide(); 4227 4228 } 4229 4230 } 4231 4232 4233 /* 4234 Focus can get lost in IE when the mouse is moving from a submenu back to its parent Menu. 4235 For this reason, it is necessary to maintain the focused state in a private property 4236 so that the _onMouseOver event handler is able to determined whether or not to set focus 4237 to MenuItems as the user is moving the mouse. 4238 */ 4239 4240 if (UA.ie && this.cfg.getProperty(_POSITION) === _DYNAMIC && this.parent) { 4241 4242 oRoot._hasFocus = this.hasFocus(); 4243 4244 } 4245 4246 4247 if (oRoot == this) { 4248 4249 oRoot.blur(); 4250 4251 } 4252 4253 }, 4254 4255 4256 /** 4257 * @method _onParentMenuConfigChange 4258 * @description "configchange" event handler for a submenu. 4259 * @private 4260 * @param {String} p_sType String representing the name of the event that 4261 * was fired. 4262 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4263 * @param {YAHOO.widget.Menu} p_oSubmenu Object representing the submenu that 4264 * subscribed to the event. 4265 */ 4266 _onParentMenuConfigChange: function (p_sType, p_aArgs, p_oSubmenu) { 4267 4268 var sPropertyName = p_aArgs[0][0], 4269 oPropertyValue = p_aArgs[0][1]; 4270 4271 switch(sPropertyName) { 4272 4273 case _IFRAME: 4274 case _CONSTRAIN_TO_VIEWPORT: 4275 case _HIDE_DELAY: 4276 case _SHOW_DELAY: 4277 case _SUBMENU_HIDE_DELAY: 4278 case _CLICK_TO_HIDE: 4279 case _EFFECT: 4280 case _CLASSNAME: 4281 case _SCROLL_INCREMENT: 4282 case _MAX_HEIGHT: 4283 case _MIN_SCROLL_HEIGHT: 4284 case _MONITOR_RESIZE: 4285 case _SHADOW: 4286 case _PREVENT_CONTEXT_OVERLAP: 4287 case _KEEP_OPEN: 4288 4289 p_oSubmenu.cfg.setProperty(sPropertyName, oPropertyValue); 4290 4291 break; 4292 4293 case _SUBMENU_ALIGNMENT: 4294 4295 if (!(this.parent.parent instanceof YAHOO.widget.MenuBar)) { 4296 4297 p_oSubmenu.cfg.setProperty(sPropertyName, oPropertyValue); 4298 4299 } 4300 4301 break; 4302 4303 } 4304 4305 }, 4306 4307 4308 /** 4309 * @method _onParentMenuRender 4310 * @description "render" event handler for a submenu. Renders a 4311 * submenu in response to the firing of its parent's "render" event. 4312 * @private 4313 * @param {String} p_sType String representing the name of the event that 4314 * was fired. 4315 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4316 * @param {YAHOO.widget.Menu} p_oSubmenu Object representing the submenu that 4317 * subscribed to the event. 4318 */ 4319 _onParentMenuRender: function (p_sType, p_aArgs, p_oSubmenu) { 4320 4321 var oParentMenu = p_oSubmenu.parent.parent, 4322 oParentCfg = oParentMenu.cfg, 4323 4324 oConfig = { 4325 4326 constraintoviewport: oParentCfg.getProperty(_CONSTRAIN_TO_VIEWPORT), 4327 4328 xy: [0,0], 4329 4330 clicktohide: oParentCfg.getProperty(_CLICK_TO_HIDE), 4331 4332 effect: oParentCfg.getProperty(_EFFECT), 4333 4334 showdelay: oParentCfg.getProperty(_SHOW_DELAY), 4335 4336 hidedelay: oParentCfg.getProperty(_HIDE_DELAY), 4337 4338 submenuhidedelay: oParentCfg.getProperty(_SUBMENU_HIDE_DELAY), 4339 4340 classname: oParentCfg.getProperty(_CLASSNAME), 4341 4342 scrollincrement: oParentCfg.getProperty(_SCROLL_INCREMENT), 4343 4344 maxheight: oParentCfg.getProperty(_MAX_HEIGHT), 4345 4346 minscrollheight: oParentCfg.getProperty(_MIN_SCROLL_HEIGHT), 4347 4348 iframe: oParentCfg.getProperty(_IFRAME), 4349 4350 shadow: oParentCfg.getProperty(_SHADOW), 4351 4352 preventcontextoverlap: oParentCfg.getProperty(_PREVENT_CONTEXT_OVERLAP), 4353 4354 monitorresize: oParentCfg.getProperty(_MONITOR_RESIZE), 4355 4356 keepopen: oParentCfg.getProperty(_KEEP_OPEN) 4357 4358 }, 4359 4360 oLI; 4361 4362 4363 4364 if (!(oParentMenu instanceof YAHOO.widget.MenuBar)) { 4365 4366 oConfig[_SUBMENU_ALIGNMENT] = oParentCfg.getProperty(_SUBMENU_ALIGNMENT); 4367 4368 } 4369 4370 4371 p_oSubmenu.cfg.applyConfig(oConfig); 4372 4373 4374 if (!this.lazyLoad) { 4375 4376 oLI = this.parent.element; 4377 4378 if (this.element.parentNode == oLI) { 4379 4380 this.render(); 4381 4382 } 4383 else { 4384 4385 this.render(oLI); 4386 4387 } 4388 4389 } 4390 4391 }, 4392 4393 4394 /** 4395 * @method _onMenuItemDestroy 4396 * @description "destroy" event handler for the menu's items. 4397 * @private 4398 * @param {String} p_sType String representing the name of the event 4399 * that was fired. 4400 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4401 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 4402 * that fired the event. 4403 */ 4404 _onMenuItemDestroy: function (p_sType, p_aArgs, p_oItem) { 4405 4406 this._removeItemFromGroupByValue(p_oItem.groupIndex, p_oItem); 4407 4408 }, 4409 4410 4411 /** 4412 * @method _onMenuItemConfigChange 4413 * @description "configchange" event handler for the menu's items. 4414 * @private 4415 * @param {String} p_sType String representing the name of the event that 4416 * was fired. 4417 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4418 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 4419 * that fired the event. 4420 */ 4421 _onMenuItemConfigChange: function (p_sType, p_aArgs, p_oItem) { 4422 4423 var sPropertyName = p_aArgs[0][0], 4424 oPropertyValue = p_aArgs[0][1], 4425 oSubmenu; 4426 4427 4428 switch(sPropertyName) { 4429 4430 case _SELECTED: 4431 4432 if (oPropertyValue === true) { 4433 4434 this.activeItem = p_oItem; 4435 4436 } 4437 4438 break; 4439 4440 case _SUBMENU: 4441 4442 oSubmenu = p_aArgs[0][1]; 4443 4444 if (oSubmenu) { 4445 4446 this._configureSubmenu(p_oItem); 4447 4448 } 4449 4450 break; 4451 4452 } 4453 4454 }, 4455 4456 4457 4458 // Public event handlers for configuration properties 4459 4460 4461 /** 4462 * @method configVisible 4463 * @description Event handler for when the "visible" configuration property 4464 * the menu changes. 4465 * @param {String} p_sType String representing the name of the event that 4466 * was fired. 4467 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4468 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 4469 * fired the event. 4470 */ 4471 configVisible: function (p_sType, p_aArgs, p_oMenu) { 4472 4473 var bVisible, 4474 sDisplay; 4475 4476 if (this.cfg.getProperty(_POSITION) == _DYNAMIC) { 4477 4478 Menu.superclass.configVisible.call(this, p_sType, p_aArgs, p_oMenu); 4479 4480 } 4481 else { 4482 4483 bVisible = p_aArgs[0]; 4484 sDisplay = Dom.getStyle(this.element, _DISPLAY); 4485 4486 Dom.setStyle(this.element, _VISIBILITY, _VISIBLE); 4487 4488 if (bVisible) { 4489 4490 if (sDisplay != _BLOCK) { 4491 this.beforeShowEvent.fire(); 4492 Dom.setStyle(this.element, _DISPLAY, _BLOCK); 4493 this.showEvent.fire(); 4494 } 4495 4496 } 4497 else { 4498 4499 if (sDisplay == _BLOCK) { 4500 this.beforeHideEvent.fire(); 4501 Dom.setStyle(this.element, _DISPLAY, _NONE); 4502 this.hideEvent.fire(); 4503 } 4504 4505 } 4506 4507 } 4508 4509 }, 4510 4511 4512 /** 4513 * @method configPosition 4514 * @description Event handler for when the "position" configuration property 4515 * of the menu changes. 4516 * @param {String} p_sType String representing the name of the event that 4517 * was fired. 4518 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4519 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 4520 * fired the event. 4521 */ 4522 configPosition: function (p_sType, p_aArgs, p_oMenu) { 4523 4524 var oElement = this.element, 4525 sCSSPosition = p_aArgs[0] == _STATIC ? _STATIC : _ABSOLUTE, 4526 oCfg = this.cfg, 4527 nZIndex; 4528 4529 4530 Dom.setStyle(oElement, _POSITION, sCSSPosition); 4531 4532 4533 if (sCSSPosition == _STATIC) { 4534 4535 // Statically positioned menus are visible by default 4536 4537 Dom.setStyle(oElement, _DISPLAY, _BLOCK); 4538 4539 oCfg.setProperty(_VISIBLE, true); 4540 4541 } 4542 else { 4543 4544 /* 4545 Even though the "visible" property is queued to 4546 "false" by default, we need to set the "visibility" property to 4547 "hidden" since Overlay's "configVisible" implementation checks the 4548 element's "visibility" style property before deciding whether 4549 or not to show an Overlay instance. 4550 */ 4551 4552 Dom.setStyle(oElement, _VISIBILITY, _HIDDEN); 4553 4554 } 4555 4556 4557 if (sCSSPosition == _ABSOLUTE) { 4558 nZIndex = oCfg.getProperty(_ZINDEX); 4559 4560 if (!nZIndex || nZIndex === 0) { 4561 oCfg.setProperty(_ZINDEX, 1); 4562 } 4563 4564 } 4565 4566 }, 4567 4568 4569 /** 4570 * @method configIframe 4571 * @description Event handler for when the "iframe" configuration property of 4572 * the menu changes. 4573 * @param {String} p_sType String representing the name of the event that 4574 * was fired. 4575 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4576 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 4577 * fired the event. 4578 */ 4579 configIframe: function (p_sType, p_aArgs, p_oMenu) { 4580 4581 if (this.cfg.getProperty(_POSITION) == _DYNAMIC) { 4582 4583 Menu.superclass.configIframe.call(this, p_sType, p_aArgs, p_oMenu); 4584 4585 } 4586 4587 }, 4588 4589 4590 /** 4591 * @method configHideDelay 4592 * @description Event handler for when the "hidedelay" configuration property 4593 * of the menu changes. 4594 * @param {String} p_sType String representing the name of the event that 4595 * was fired. 4596 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4597 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 4598 * fired the event. 4599 */ 4600 configHideDelay: function (p_sType, p_aArgs, p_oMenu) { 4601 4602 var nHideDelay = p_aArgs[0]; 4603 4604 this._useHideDelay = (nHideDelay > 0); 4605 4606 }, 4607 4608 4609 /** 4610 * @method configContainer 4611 * @description Event handler for when the "container" configuration property 4612 * of the menu changes. 4613 * @param {String} p_sType String representing the name of the event that 4614 * was fired. 4615 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 4616 * @param {YAHOO.widget.Menu} p_oMenu Object representing the menu that 4617 * fired the event. 4618 */ 4619 configContainer: function (p_sType, p_aArgs, p_oMenu) { 4620 4621 var oElement = p_aArgs[0]; 4622 4623 if (Lang.isString(oElement)) { 4624 4625 this.cfg.setProperty(_CONTAINER, Dom.get(oElement), true); 4626 4627 } 4628 4629 }, 4630 4631 4632 /** 4633 * @method _clearSetWidthFlag 4634 * @description Change event listener for the "width" configuration property. This listener is 4635 * added when a Menu's "width" configuration property is set by the "_setScrollHeight" method, and 4636 * is used to set the "_widthSetForScroll" property to "false" if the "width" configuration property 4637 * is changed after it was set by the "_setScrollHeight" method. If the "_widthSetForScroll" 4638 * property is set to "false", and the "_setScrollHeight" method is in the process of tearing down 4639 * scrolling functionality, it will maintain the Menu's new width rather than reseting it. 4640 * @private 4641 */ 4642 _clearSetWidthFlag: function () { 4643 4644 this._widthSetForScroll = false; 4645 4646 this.cfg.unsubscribeFromConfigEvent(_WIDTH, this._clearSetWidthFlag); 4647 4648 }, 4649 4650 /** 4651 * @method _subscribeScrollHandlers 4652 * @param {HTMLElement} oHeader The scroll header element 4653 * @param {HTMLElement} oFooter The scroll footer element 4654 */ 4655 _subscribeScrollHandlers : function(oHeader, oFooter) { 4656 var fnMouseOver = this._onScrollTargetMouseOver; 4657 var fnMouseOut = this._onScrollTargetMouseOut; 4658 4659 Event.on(oHeader, _MOUSEOVER, fnMouseOver, this, true); 4660 Event.on(oHeader, _MOUSEOUT, fnMouseOut, this, true); 4661 Event.on(oFooter, _MOUSEOVER, fnMouseOver, this, true); 4662 Event.on(oFooter, _MOUSEOUT, fnMouseOut, this, true); 4663 }, 4664 4665 /** 4666 * @method _unsubscribeScrollHandlers 4667 * @param {HTMLElement} oHeader The scroll header element 4668 * @param {HTMLElement} oFooter The scroll footer element 4669 */ 4670 _unsubscribeScrollHandlers : function(oHeader, oFooter) { 4671 var fnMouseOver = this._onScrollTargetMouseOver; 4672 var fnMouseOut = this._onScrollTargetMouseOut; 4673 4674 Event.removeListener(oHeader, _MOUSEOVER, fnMouseOver); 4675 Event.removeListener(oHeader, _MOUSEOUT, fnMouseOut); 4676 Event.removeListener(oFooter, _MOUSEOVER, fnMouseOver); 4677 Event.removeListener(oFooter, _MOUSEOUT, fnMouseOut); 4678 }, 4679 4680 /** 4681 * @method _setScrollHeight 4682 * @description 4683 * @param {String} p_nScrollHeight Number representing the scrolling height of the Menu. 4684 * @private 4685 */ 4686 _setScrollHeight: function (p_nScrollHeight) { 4687 4688 var nScrollHeight = p_nScrollHeight, 4689 bRefireIFrameAndShadow = false, 4690 bSetWidth = false, 4691 oElement, 4692 oBody, 4693 oHeader, 4694 oFooter, 4695 nMinScrollHeight, 4696 nHeight, 4697 nOffsetWidth, 4698 sWidth; 4699 4700 if (this.getItems().length > 0) { 4701 4702 oElement = this.element; 4703 oBody = this.body; 4704 oHeader = this.header; 4705 oFooter = this.footer; 4706 nMinScrollHeight = this.cfg.getProperty(_MIN_SCROLL_HEIGHT); 4707 4708 if (nScrollHeight > 0 && nScrollHeight < nMinScrollHeight) { 4709 nScrollHeight = nMinScrollHeight; 4710 } 4711 4712 Dom.setStyle(oBody, _HEIGHT, _EMPTY_STRING); 4713 Dom.removeClass(oBody, _YUI_MENU_BODY_SCROLLED); 4714 oBody.scrollTop = 0; 4715 4716 // Need to set a width for the Menu to fix the following problems in 4717 // Firefox 2 and IE: 4718 4719 // #1) Scrolled Menus will render at 1px wide in Firefox 2 4720 4721 // #2) There is a bug in gecko-based browsers where an element whose 4722 // "position" property is set to "absolute" and "overflow" property is 4723 // set to "hidden" will not render at the correct width when its 4724 // offsetParent's "position" property is also set to "absolute." It is 4725 // possible to work around this bug by specifying a value for the width 4726 // property in addition to overflow. 4727 4728 // #3) In IE it is necessary to give the Menu a width before the 4729 // scrollbars are rendered to prevent the Menu from rendering with a 4730 // width that is 100% of the browser viewport. 4731 4732 bSetWidth = ((UA.gecko && UA.gecko < 1.9) || UA.ie); 4733 4734 if (nScrollHeight > 0 && bSetWidth && !this.cfg.getProperty(_WIDTH)) { 4735 4736 nOffsetWidth = oElement.offsetWidth; 4737 4738 /* 4739 Measuring the difference of the offsetWidth before and after 4740 setting the "width" style attribute allows us to compute the 4741 about of padding and borders applied to the element, which in 4742 turn allows us to set the "width" property correctly. 4743 */ 4744 4745 oElement.style.width = nOffsetWidth + _PX; 4746 4747 sWidth = (nOffsetWidth - (oElement.offsetWidth - nOffsetWidth)) + _PX; 4748 4749 4750 this.cfg.unsubscribeFromConfigEvent(_WIDTH, this._clearSetWidthFlag); 4751 4752 YAHOO.log("Setting the \"width\" configuration property to " + sWidth + " for srolling.", 4753 "info", this.toString()); 4754 4755 this.cfg.setProperty(_WIDTH, sWidth); 4756 4757 4758 /* 4759 Set a flag (_widthSetForScroll) to maintain some history regarding how the 4760 "width" configuration property was set. If the "width" configuration property 4761 is set by something other than the "_setScrollHeight" method, it will be 4762 necessary to maintain that new value and not clear the width if scrolling 4763 is turned off. 4764 */ 4765 4766 this._widthSetForScroll = true; 4767 4768 this.cfg.subscribeToConfigEvent(_WIDTH, this._clearSetWidthFlag); 4769 4770 } 4771 4772 4773 if (nScrollHeight > 0 && (!oHeader && !oFooter)) { 4774 4775 YAHOO.log("Creating header and footer for scrolling.", "info", this.toString()); 4776 4777 this.setHeader(_NON_BREAKING_SPACE); 4778 this.setFooter(_NON_BREAKING_SPACE); 4779 4780 oHeader = this.header; 4781 oFooter = this.footer; 4782 4783 Dom.addClass(oHeader, _TOP_SCROLLBAR); 4784 Dom.addClass(oFooter, _BOTTOM_SCROLLBAR); 4785 4786 oElement.insertBefore(oHeader, oBody); 4787 oElement.appendChild(oFooter); 4788 4789 } 4790 4791 nHeight = nScrollHeight; 4792 4793 if (oHeader && oFooter) { 4794 nHeight = (nHeight - (oHeader.offsetHeight + oFooter.offsetHeight)); 4795 } 4796 4797 4798 if ((nHeight > 0) && (oBody.offsetHeight > nScrollHeight)) { 4799 4800 YAHOO.log("Setting up styles and event handlers for scrolling.", 4801 "info", this.toString()); 4802 4803 Dom.addClass(oBody, _YUI_MENU_BODY_SCROLLED); 4804 Dom.setStyle(oBody, _HEIGHT, (nHeight + _PX)); 4805 4806 if (!this._hasScrollEventHandlers) { 4807 this._subscribeScrollHandlers(oHeader, oFooter); 4808 this._hasScrollEventHandlers = true; 4809 } 4810 4811 this._disableScrollHeader(); 4812 this._enableScrollFooter(); 4813 4814 bRefireIFrameAndShadow = true; 4815 4816 } 4817 else if (oHeader && oFooter) { 4818 4819 YAHOO.log("Removing styles and event handlers for scrolling.", "info", this.toString()); 4820 4821 4822 /* 4823 Only clear the the "width" configuration property if it was set the 4824 "_setScrollHeight" method and wasn't changed by some other means after it was set. 4825 */ 4826 4827 if (this._widthSetForScroll) { 4828 4829 YAHOO.log("Clearing width used for scrolling.", "info", this.toString()); 4830 4831 this._widthSetForScroll = false; 4832 4833 this.cfg.unsubscribeFromConfigEvent(_WIDTH, this._clearSetWidthFlag); 4834 4835 this.cfg.setProperty(_WIDTH, _EMPTY_STRING); 4836 4837 } 4838 4839 4840 this._enableScrollHeader(); 4841 this._enableScrollFooter(); 4842 4843 if (this._hasScrollEventHandlers) { 4844 this._unsubscribeScrollHandlers(oHeader, oFooter); 4845 this._hasScrollEventHandlers = false; 4846 } 4847 4848 oElement.removeChild(oHeader); 4849 oElement.removeChild(oFooter); 4850 4851 this.header = null; 4852 this.footer = null; 4853 4854 bRefireIFrameAndShadow = true; 4855 4856 } 4857 4858 4859 if (bRefireIFrameAndShadow) { 4860 4861 this.cfg.refireEvent(_IFRAME); 4862 this.cfg.refireEvent(_SHADOW); 4863 4864 } 4865 4866 } 4867 4868 }, 4869 4870 4871 /** 4872 * @method _setMaxHeight 4873 * @description "renderEvent" handler used to defer the setting of the 4874 * "maxheight" configuration property until the menu is rendered in lazy 4875 * load scenarios. 4876 * @param {String} p_sType The name of the event that was fired. 4877 * @param {Array} p_aArgs Collection of arguments sent when the event 4878 * was fired. 4879 * @param {Number} p_nMaxHeight Number representing the value to set for the 4880 * "maxheight" configuration property. 4881 * @private 4882 */ 4883 _setMaxHeight: function (p_sType, p_aArgs, p_nMaxHeight) { 4884 4885 this._setScrollHeight(p_nMaxHeight); 4886 this.renderEvent.unsubscribe(this._setMaxHeight); 4887 4888 }, 4889 4890 4891 /** 4892 * @method configMaxHeight 4893 * @description Event handler for when the "maxheight" configuration property of 4894 * a Menu changes. 4895 * @param {String} p_sType The name of the event that was fired. 4896 * @param {Array} p_aArgs Collection of arguments sent when the event 4897 * was fired. 4898 * @param {YAHOO.widget.Menu} p_oMenu The Menu instance fired 4899 * the event. 4900 */ 4901 configMaxHeight: function (p_sType, p_aArgs, p_oMenu) { 4902 4903 var nMaxHeight = p_aArgs[0]; 4904 4905 if (this.lazyLoad && !this.body && nMaxHeight > 0) { 4906 4907 this.renderEvent.subscribe(this._setMaxHeight, nMaxHeight, this); 4908 4909 } 4910 else { 4911 4912 this._setScrollHeight(nMaxHeight); 4913 4914 } 4915 4916 }, 4917 4918 4919 /** 4920 * @method configClassName 4921 * @description Event handler for when the "classname" configuration property of 4922 * a menu changes. 4923 * @param {String} p_sType The name of the event that was fired. 4924 * @param {Array} p_aArgs Collection of arguments sent when the event was fired. 4925 * @param {YAHOO.widget.Menu} p_oMenu The Menu instance fired the event. 4926 */ 4927 configClassName: function (p_sType, p_aArgs, p_oMenu) { 4928 4929 var sClassName = p_aArgs[0]; 4930 4931 if (this._sClassName) { 4932 4933 Dom.removeClass(this.element, this._sClassName); 4934 4935 } 4936 4937 Dom.addClass(this.element, sClassName); 4938 this._sClassName = sClassName; 4939 4940 }, 4941 4942 4943 /** 4944 * @method _onItemAdded 4945 * @description "itemadded" event handler for a Menu instance. 4946 * @private 4947 * @param {String} p_sType The name of the event that was fired. 4948 * @param {Array} p_aArgs Collection of arguments sent when the event 4949 * was fired. 4950 */ 4951 _onItemAdded: function (p_sType, p_aArgs) { 4952 4953 var oItem = p_aArgs[0]; 4954 4955 if (oItem) { 4956 4957 oItem.cfg.setProperty(_DISABLED, true); 4958 4959 } 4960 4961 }, 4962 4963 4964 /** 4965 * @method configDisabled 4966 * @description Event handler for when the "disabled" configuration property of 4967 * a menu changes. 4968 * @param {String} p_sType The name of the event that was fired. 4969 * @param {Array} p_aArgs Collection of arguments sent when the event was fired. 4970 * @param {YAHOO.widget.Menu} p_oMenu The Menu instance fired the event. 4971 */ 4972 configDisabled: function (p_sType, p_aArgs, p_oMenu) { 4973 4974 var bDisabled = p_aArgs[0], 4975 aItems = this.getItems(), 4976 nItems, 4977 i; 4978 4979 if (Lang.isArray(aItems)) { 4980 4981 nItems = aItems.length; 4982 4983 if (nItems > 0) { 4984 4985 i = nItems - 1; 4986 4987 do { 4988 4989 aItems[i].cfg.setProperty(_DISABLED, bDisabled); 4990 4991 } 4992 while (i--); 4993 4994 } 4995 4996 4997 if (bDisabled) { 4998 4999 this.clearActiveItem(true); 5000 5001 Dom.addClass(this.element, _DISABLED); 5002 5003 this.itemAddedEvent.subscribe(this._onItemAdded); 5004 5005 } 5006 else { 5007 5008 Dom.removeClass(this.element, _DISABLED); 5009 5010 this.itemAddedEvent.unsubscribe(this._onItemAdded); 5011 5012 } 5013 5014 } 5015 5016 }, 5017 5018 /** 5019 * Resizes the shadow to match the container bounding element 5020 * 5021 * @method _sizeShadow 5022 * @protected 5023 */ 5024 _sizeShadow : function () { 5025 5026 var oElement = this.element, 5027 oShadow = this._shadow; 5028 5029 if (oShadow && oElement) { 5030 // Clear the previous width 5031 if (oShadow.style.width && oShadow.style.height) { 5032 oShadow.style.width = _EMPTY_STRING; 5033 oShadow.style.height = _EMPTY_STRING; 5034 } 5035 5036 oShadow.style.width = (oElement.offsetWidth + 6) + _PX; 5037 oShadow.style.height = (oElement.offsetHeight + 1) + _PX; 5038 } 5039 }, 5040 5041 /** 5042 * Replaces the shadow element in the DOM with the current shadow element (this._shadow) 5043 * 5044 * @method _replaceShadow 5045 * @protected 5046 */ 5047 _replaceShadow : function () { 5048 this.element.appendChild(this._shadow); 5049 }, 5050 5051 /** 5052 * Adds the classname marker for a visible shadow, to the shadow element 5053 * 5054 * @method _addShadowVisibleClass 5055 * @protected 5056 */ 5057 _addShadowVisibleClass : function () { 5058 Dom.addClass(this._shadow, _YUI_MENU_SHADOW_VISIBLE); 5059 }, 5060 5061 /** 5062 * Removes the classname marker for a visible shadow, from the shadow element 5063 * 5064 * @method _removeShadowVisibleClass 5065 * @protected 5066 */ 5067 _removeShadowVisibleClass : function () { 5068 Dom.removeClass(this._shadow, _YUI_MENU_SHADOW_VISIBLE); 5069 }, 5070 5071 /** 5072 * Removes the shadow element from the DOM, and unsubscribes all the listeners used to keep it in sync. Used 5073 * to handle setting the shadow to false. 5074 * 5075 * @method _removeShadow 5076 * @protected 5077 */ 5078 _removeShadow : function() { 5079 5080 var p = (this._shadow && this._shadow.parentNode); 5081 5082 if (p) { 5083 p.removeChild(this._shadow); 5084 } 5085 5086 this.beforeShowEvent.unsubscribe(this._addShadowVisibleClass); 5087 this.beforeHideEvent.unsubscribe(this._removeShadowVisibleClass); 5088 5089 this.cfg.unsubscribeFromConfigEvent(_WIDTH, this._sizeShadow); 5090 this.cfg.unsubscribeFromConfigEvent(_HEIGHT, this._sizeShadow); 5091 this.cfg.unsubscribeFromConfigEvent(_MAX_HEIGHT, this._sizeShadow); 5092 this.cfg.unsubscribeFromConfigEvent(_MAX_HEIGHT, this._replaceShadow); 5093 5094 this.changeContentEvent.unsubscribe(this._sizeShadow); 5095 5096 Module.textResizeEvent.unsubscribe(this._sizeShadow); 5097 }, 5098 5099 /** 5100 * Used to create the shadow element, add it to the DOM, and subscribe listeners to keep it in sync. 5101 * 5102 * @method _createShadow 5103 * @protected 5104 */ 5105 _createShadow : function () { 5106 5107 var oShadow = this._shadow, 5108 oElement; 5109 5110 if (!oShadow) { 5111 oElement = this.element; 5112 5113 if (!m_oShadowTemplate) { 5114 m_oShadowTemplate = document.createElement(_DIV_LOWERCASE); 5115 m_oShadowTemplate.className = _YUI_MENU_SHADOW_YUI_MENU_SHADOW_VISIBLE; 5116 } 5117 5118 oShadow = m_oShadowTemplate.cloneNode(false); 5119 5120 oElement.appendChild(oShadow); 5121 5122 this._shadow = oShadow; 5123 5124 this.beforeShowEvent.subscribe(this._addShadowVisibleClass); 5125 this.beforeHideEvent.subscribe(this._removeShadowVisibleClass); 5126 5127 if (UA.ie) { 5128 /* 5129 Need to call sizeShadow & syncIframe via setTimeout for 5130 IE 7 Quirks Mode and IE 6 Standards Mode and Quirks Mode 5131 or the shadow and iframe shim will not be sized and 5132 positioned properly. 5133 */ 5134 Lang.later(0, this, function () { 5135 this._sizeShadow(); 5136 this.syncIframe(); 5137 }); 5138 5139 this.cfg.subscribeToConfigEvent(_WIDTH, this._sizeShadow); 5140 this.cfg.subscribeToConfigEvent(_HEIGHT, this._sizeShadow); 5141 this.cfg.subscribeToConfigEvent(_MAX_HEIGHT, this._sizeShadow); 5142 this.changeContentEvent.subscribe(this._sizeShadow); 5143 5144 Module.textResizeEvent.subscribe(this._sizeShadow, this, true); 5145 5146 this.destroyEvent.subscribe(function () { 5147 Module.textResizeEvent.unsubscribe(this._sizeShadow, this); 5148 }); 5149 } 5150 5151 this.cfg.subscribeToConfigEvent(_MAX_HEIGHT, this._replaceShadow); 5152 } 5153 }, 5154 5155 /** 5156 * The beforeShow event handler used to set up the shadow lazily when the menu is made visible. 5157 * @method _shadowBeforeShow 5158 * @protected 5159 */ 5160 _shadowBeforeShow : function () { 5161 if (this._shadow) { 5162 5163 // If called because the "shadow" event was refired - just append again and resize 5164 this._replaceShadow(); 5165 5166 if (UA.ie) { 5167 this._sizeShadow(); 5168 } 5169 } else { 5170 this._createShadow(); 5171 } 5172 5173 this.beforeShowEvent.unsubscribe(this._shadowBeforeShow); 5174 }, 5175 5176 /** 5177 * @method configShadow 5178 * @description Event handler for when the "shadow" configuration property of 5179 * a menu changes. 5180 * @param {String} p_sType The name of the event that was fired. 5181 * @param {Array} p_aArgs Collection of arguments sent when the event was fired. 5182 * @param {YAHOO.widget.Menu} p_oMenu The Menu instance fired the event. 5183 */ 5184 configShadow: function (p_sType, p_aArgs, p_oMenu) { 5185 5186 var bShadow = p_aArgs[0]; 5187 5188 if (bShadow && this.cfg.getProperty(_POSITION) == _DYNAMIC) { 5189 if (this.cfg.getProperty(_VISIBLE)) { 5190 if (this._shadow) { 5191 // If the "shadow" event was refired - just append again and resize 5192 this._replaceShadow(); 5193 5194 if (UA.ie) { 5195 this._sizeShadow(); 5196 } 5197 } else { 5198 this._createShadow(); 5199 } 5200 } else { 5201 this.beforeShowEvent.subscribe(this._shadowBeforeShow); 5202 } 5203 } else if (!bShadow) { 5204 this.beforeShowEvent.unsubscribe(this._shadowBeforeShow); 5205 this._removeShadow(); 5206 } 5207 }, 5208 5209 // Public methods 5210 5211 /** 5212 * @method initEvents 5213 * @description Initializes the custom events for the menu. 5214 */ 5215 initEvents: function () { 5216 5217 Menu.superclass.initEvents.call(this); 5218 5219 // Create custom events 5220 5221 var i = EVENT_TYPES.length - 1, 5222 aEventData, 5223 oCustomEvent; 5224 5225 5226 do { 5227 5228 aEventData = EVENT_TYPES[i]; 5229 5230 oCustomEvent = this.createEvent(aEventData[1]); 5231 oCustomEvent.signature = CustomEvent.LIST; 5232 5233 this[aEventData[0]] = oCustomEvent; 5234 5235 } 5236 while (i--); 5237 5238 }, 5239 5240 5241 /** 5242 * @method positionOffScreen 5243 * @description Positions the menu outside of the boundaries of the browser's 5244 * viewport. Called automatically when a menu is hidden to ensure that 5245 * it doesn't force the browser to render uncessary scrollbars. 5246 */ 5247 positionOffScreen: function () { 5248 5249 var oIFrame = this.iframe, 5250 oElement = this.element, 5251 sPos = this.OFF_SCREEN_POSITION; 5252 5253 oElement.style.top = _EMPTY_STRING; 5254 oElement.style.left = _EMPTY_STRING; 5255 5256 if (oIFrame) { 5257 5258 oIFrame.style.top = sPos; 5259 oIFrame.style.left = sPos; 5260 5261 } 5262 5263 }, 5264 5265 5266 /** 5267 * @method getRoot 5268 * @description Finds the menu's root menu. 5269 */ 5270 getRoot: function () { 5271 5272 var oItem = this.parent, 5273 oParentMenu, 5274 returnVal; 5275 5276 if (oItem) { 5277 5278 oParentMenu = oItem.parent; 5279 5280 returnVal = oParentMenu ? oParentMenu.getRoot() : this; 5281 5282 } 5283 else { 5284 5285 returnVal = this; 5286 5287 } 5288 5289 return returnVal; 5290 5291 }, 5292 5293 5294 /** 5295 * @method toString 5296 * @description Returns a string representing the menu. 5297 * @return {String} 5298 */ 5299 toString: function () { 5300 5301 var sReturnVal = _MENU, 5302 sId = this.id; 5303 5304 if (sId) { 5305 5306 sReturnVal += (_SPACE + sId); 5307 5308 } 5309 5310 return sReturnVal; 5311 5312 }, 5313 5314 5315 /** 5316 * @method setItemGroupTitle 5317 * @description Sets the title of a group of menu items. 5318 * @param {HTML} p_sGroupTitle String or markup specifying the title of the group. The title is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 5319 * @param {Number} p_nGroupIndex Optional. Number specifying the group to which 5320 * the title belongs. 5321 */ 5322 setItemGroupTitle: function (p_sGroupTitle, p_nGroupIndex) { 5323 5324 var nGroupIndex, 5325 oTitle, 5326 i, 5327 nFirstIndex; 5328 5329 if (Lang.isString(p_sGroupTitle) && p_sGroupTitle.length > 0) { 5330 5331 nGroupIndex = Lang.isNumber(p_nGroupIndex) ? p_nGroupIndex : 0; 5332 oTitle = this._aGroupTitleElements[nGroupIndex]; 5333 5334 5335 if (oTitle) { 5336 5337 oTitle.innerHTML = p_sGroupTitle; 5338 5339 } 5340 else { 5341 5342 oTitle = document.createElement(this.GROUP_TITLE_TAG_NAME); 5343 5344 oTitle.innerHTML = p_sGroupTitle; 5345 5346 this._aGroupTitleElements[nGroupIndex] = oTitle; 5347 5348 } 5349 5350 5351 i = this._aGroupTitleElements.length - 1; 5352 5353 do { 5354 5355 if (this._aGroupTitleElements[i]) { 5356 5357 Dom.removeClass(this._aGroupTitleElements[i], _FIRST_OF_TYPE); 5358 5359 nFirstIndex = i; 5360 5361 } 5362 5363 } 5364 while (i--); 5365 5366 5367 if (nFirstIndex !== null) { 5368 5369 Dom.addClass(this._aGroupTitleElements[nFirstIndex], 5370 _FIRST_OF_TYPE); 5371 5372 } 5373 5374 this.changeContentEvent.fire(); 5375 5376 } 5377 5378 }, 5379 5380 5381 5382 /** 5383 * @method addItem 5384 * @description Appends an item to the menu. 5385 * @param {YAHOO.widget.MenuItem} p_oItem Object reference for the MenuItem 5386 * instance to be added to the menu. 5387 * @param {HTML} p_oItem String or markup specifying content of the item to be added 5388 * to the menu. The item text is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 5389 * @param {Object} p_oItem Object literal containing a set of menu item 5390 * configuration properties. 5391 * @param {Number} p_nGroupIndex Optional. Number indicating the group to 5392 * which the item belongs. 5393 * @return {YAHOO.widget.MenuItem} 5394 */ 5395 addItem: function (p_oItem, p_nGroupIndex) { 5396 5397 return this._addItemToGroup(p_nGroupIndex, p_oItem); 5398 5399 }, 5400 5401 5402 /** 5403 * @method addItems 5404 * @description Adds an array of items to the menu. 5405 * @param {Array} p_aItems Array of items to be added to the menu. The array 5406 * can contain strings specifying the markup for the content of each item to be created, object 5407 * literals specifying each of the menu item configuration properties, 5408 * or MenuItem instances. The item content if provided as a string is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 5409 * @param {Number} p_nGroupIndex Optional. Number specifying the group to 5410 * which the items belongs. 5411 * @return {Array} 5412 */ 5413 addItems: function (p_aItems, p_nGroupIndex) { 5414 5415 var nItems, 5416 aItems, 5417 oItem, 5418 i, 5419 returnVal; 5420 5421 5422 if (Lang.isArray(p_aItems)) { 5423 5424 nItems = p_aItems.length; 5425 aItems = []; 5426 5427 for(i=0; i<nItems; i++) { 5428 5429 oItem = p_aItems[i]; 5430 5431 if (oItem) { 5432 5433 if (Lang.isArray(oItem)) { 5434 5435 aItems[aItems.length] = this.addItems(oItem, i); 5436 5437 } 5438 else { 5439 5440 aItems[aItems.length] = this._addItemToGroup(p_nGroupIndex, oItem); 5441 5442 } 5443 5444 } 5445 5446 } 5447 5448 5449 if (aItems.length) { 5450 5451 returnVal = aItems; 5452 5453 } 5454 5455 } 5456 5457 return returnVal; 5458 5459 }, 5460 5461 5462 /** 5463 * @method insertItem 5464 * @description Inserts an item into the menu at the specified index. 5465 * @param {YAHOO.widget.MenuItem} p_oItem Object reference for the MenuItem 5466 * instance to be added to the menu. 5467 * @param {String} p_oItem String specifying the text of the item to be added 5468 * to the menu. 5469 * @param {Object} p_oItem Object literal containing a set of menu item 5470 * configuration properties. 5471 * @param {Number} p_nItemIndex Number indicating the ordinal position at which 5472 * the item should be added. 5473 * @param {Number} p_nGroupIndex Optional. Number indicating the group to which 5474 * the item belongs. 5475 * @return {YAHOO.widget.MenuItem} 5476 */ 5477 insertItem: function (p_oItem, p_nItemIndex, p_nGroupIndex) { 5478 5479 return this._addItemToGroup(p_nGroupIndex, p_oItem, p_nItemIndex); 5480 5481 }, 5482 5483 5484 /** 5485 * @method removeItem 5486 * @description Removes the specified item from the menu. 5487 * @param {YAHOO.widget.MenuItem} p_oObject Object reference for the MenuItem 5488 * instance to be removed from the menu. 5489 * @param {Number} p_oObject Number specifying the index of the item 5490 * to be removed. 5491 * @param {Number} p_nGroupIndex Optional. Number specifying the group to 5492 * which the item belongs. 5493 * @return {YAHOO.widget.MenuItem} 5494 */ 5495 removeItem: function (p_oObject, p_nGroupIndex) { 5496 5497 var oItem, 5498 returnVal; 5499 5500 if (!Lang.isUndefined(p_oObject)) { 5501 5502 if (p_oObject instanceof YAHOO.widget.MenuItem) { 5503 5504 oItem = this._removeItemFromGroupByValue(p_nGroupIndex, p_oObject); 5505 5506 } 5507 else if (Lang.isNumber(p_oObject)) { 5508 5509 oItem = this._removeItemFromGroupByIndex(p_nGroupIndex, p_oObject); 5510 5511 } 5512 5513 if (oItem) { 5514 5515 oItem.destroy(); 5516 5517 YAHOO.log("Item removed." + 5518 " Text: " + oItem.cfg.getProperty("text") + ", " + 5519 " Index: " + oItem.index + ", " + 5520 " Group Index: " + oItem.groupIndex, "info", this.toString()); 5521 5522 returnVal = oItem; 5523 5524 } 5525 5526 } 5527 5528 return returnVal; 5529 5530 }, 5531 5532 5533 /** 5534 * @method getItems 5535 * @description Returns an array of all of the items in the menu. 5536 * @return {Array} 5537 */ 5538 getItems: function () { 5539 5540 var aGroups = this._aItemGroups, 5541 nGroups, 5542 returnVal, 5543 aItems = []; 5544 5545 5546 if (Lang.isArray(aGroups)) { 5547 5548 nGroups = aGroups.length; 5549 5550 returnVal = ((nGroups == 1) ? aGroups[0] : (Array.prototype.concat.apply(aItems, aGroups))); 5551 5552 } 5553 5554 return returnVal; 5555 5556 }, 5557 5558 5559 /** 5560 * @method getItemGroups 5561 * @description Multi-dimensional Array representing the menu items as they 5562 * are grouped in the menu. 5563 * @return {Array} 5564 */ 5565 getItemGroups: function () { 5566 5567 return this._aItemGroups; 5568 5569 }, 5570 5571 5572 /** 5573 * @method getItem 5574 * @description Returns the item at the specified index. 5575 * @param {Number} p_nItemIndex Number indicating the ordinal position of the 5576 * item to be retrieved. 5577 * @param {Number} p_nGroupIndex Optional. Number indicating the group to which 5578 * the item belongs. 5579 * @return {YAHOO.widget.MenuItem} 5580 */ 5581 getItem: function (p_nItemIndex, p_nGroupIndex) { 5582 5583 var aGroup, 5584 returnVal; 5585 5586 if (Lang.isNumber(p_nItemIndex)) { 5587 5588 aGroup = this._getItemGroup(p_nGroupIndex); 5589 5590 if (aGroup) { 5591 5592 returnVal = aGroup[p_nItemIndex]; 5593 5594 } 5595 5596 } 5597 5598 return returnVal; 5599 5600 }, 5601 5602 5603 /** 5604 * @method getSubmenus 5605 * @description Returns an array of all of the submenus that are immediate 5606 * children of the menu. 5607 * @return {Array} 5608 */ 5609 getSubmenus: function () { 5610 5611 var aItems = this.getItems(), 5612 nItems = aItems.length, 5613 aSubmenus, 5614 oSubmenu, 5615 oItem, 5616 i; 5617 5618 5619 if (nItems > 0) { 5620 5621 aSubmenus = []; 5622 5623 for(i=0; i<nItems; i++) { 5624 5625 oItem = aItems[i]; 5626 5627 if (oItem) { 5628 5629 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 5630 5631 if (oSubmenu) { 5632 5633 aSubmenus[aSubmenus.length] = oSubmenu; 5634 5635 } 5636 5637 } 5638 5639 } 5640 5641 } 5642 5643 return aSubmenus; 5644 5645 }, 5646 5647 5648 /** 5649 * @method clearContent 5650 * @description Removes all of the content from the menu, including the menu 5651 * items, group titles, header and footer. 5652 */ 5653 clearContent: function () { 5654 5655 var aItems = this.getItems(), 5656 nItems = aItems.length, 5657 oElement = this.element, 5658 oBody = this.body, 5659 oHeader = this.header, 5660 oFooter = this.footer, 5661 oItem, 5662 oSubmenu, 5663 i; 5664 5665 5666 if (nItems > 0) { 5667 5668 i = nItems - 1; 5669 5670 do { 5671 5672 oItem = aItems[i]; 5673 5674 if (oItem) { 5675 5676 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 5677 5678 if (oSubmenu) { 5679 5680 this.cfg.configChangedEvent.unsubscribe( 5681 this._onParentMenuConfigChange, oSubmenu); 5682 5683 this.renderEvent.unsubscribe(this._onParentMenuRender, 5684 oSubmenu); 5685 5686 } 5687 5688 this.removeItem(oItem, oItem.groupIndex); 5689 5690 } 5691 5692 } 5693 while (i--); 5694 5695 } 5696 5697 5698 if (oHeader) { 5699 5700 Event.purgeElement(oHeader); 5701 oElement.removeChild(oHeader); 5702 5703 } 5704 5705 5706 if (oFooter) { 5707 5708 Event.purgeElement(oFooter); 5709 oElement.removeChild(oFooter); 5710 } 5711 5712 5713 if (oBody) { 5714 5715 Event.purgeElement(oBody); 5716 5717 oBody.innerHTML = _EMPTY_STRING; 5718 5719 } 5720 5721 this.activeItem = null; 5722 5723 this._aItemGroups = []; 5724 this._aListElements = []; 5725 this._aGroupTitleElements = []; 5726 5727 this.cfg.setProperty(_WIDTH, null); 5728 5729 }, 5730 5731 5732 /** 5733 * @method destroy 5734 * @description Removes the menu's <code><div></code> element 5735 * (and accompanying child nodes) from the document. 5736 * @param {boolean} shallowPurge If true, only the parent element's DOM event listeners are purged. If false, or not provided, all children are also purged of DOM event listeners. 5737 * NOTE: The flag is a "shallowPurge" flag, as opposed to what may be a more intuitive "purgeChildren" flag to maintain backwards compatibility with behavior prior to 2.9.0. 5738 * 5739 */ 5740 destroy: function (shallowPurge) { 5741 5742 // Remove all items 5743 5744 this.clearContent(); 5745 5746 this._aItemGroups = null; 5747 this._aListElements = null; 5748 this._aGroupTitleElements = null; 5749 5750 5751 // Continue with the superclass implementation of this method 5752 5753 Menu.superclass.destroy.call(this, shallowPurge); 5754 5755 YAHOO.log("Destroyed.", "info", this.toString()); 5756 5757 }, 5758 5759 5760 /** 5761 * @method setInitialFocus 5762 * @description Sets focus to the menu's first enabled item. 5763 */ 5764 setInitialFocus: function () { 5765 5766 var oItem = this._getFirstEnabledItem(); 5767 5768 if (oItem) { 5769 5770 oItem.focus(); 5771 5772 } 5773 5774 }, 5775 5776 5777 /** 5778 * @method setInitialSelection 5779 * @description Sets the "selected" configuration property of the menu's first 5780 * enabled item to "true." 5781 */ 5782 setInitialSelection: function () { 5783 5784 var oItem = this._getFirstEnabledItem(); 5785 5786 if (oItem) { 5787 5788 oItem.cfg.setProperty(_SELECTED, true); 5789 } 5790 5791 }, 5792 5793 5794 /** 5795 * @method clearActiveItem 5796 * @description Sets the "selected" configuration property of the menu's active 5797 * item to "false" and hides the item's submenu. 5798 * @param {Boolean} p_bBlur Boolean indicating if the menu's active item 5799 * should be blurred. 5800 */ 5801 clearActiveItem: function (p_bBlur) { 5802 5803 if (this.cfg.getProperty(_SHOW_DELAY) > 0) { 5804 5805 this._cancelShowDelay(); 5806 5807 } 5808 5809 5810 var oActiveItem = this.activeItem, 5811 oConfig, 5812 oSubmenu; 5813 5814 if (oActiveItem) { 5815 5816 oConfig = oActiveItem.cfg; 5817 5818 if (p_bBlur) { 5819 5820 oActiveItem.blur(); 5821 5822 this.getRoot()._hasFocus = true; 5823 5824 } 5825 5826 oConfig.setProperty(_SELECTED, false); 5827 5828 oSubmenu = oConfig.getProperty(_SUBMENU); 5829 5830 5831 if (oSubmenu) { 5832 5833 oSubmenu.hide(); 5834 5835 } 5836 5837 this.activeItem = null; 5838 5839 } 5840 5841 }, 5842 5843 5844 /** 5845 * @method focus 5846 * @description Causes the menu to receive focus and fires the "focus" event. 5847 */ 5848 focus: function () { 5849 5850 if (!this.hasFocus()) { 5851 5852 this.setInitialFocus(); 5853 5854 } 5855 5856 }, 5857 5858 5859 /** 5860 * @method blur 5861 * @description Causes the menu to lose focus and fires the "blur" event. 5862 */ 5863 blur: function () { 5864 5865 var oItem; 5866 5867 if (this.hasFocus()) { 5868 5869 oItem = MenuManager.getFocusedMenuItem(); 5870 5871 if (oItem) { 5872 5873 oItem.blur(); 5874 5875 } 5876 5877 } 5878 5879 }, 5880 5881 5882 /** 5883 * @method hasFocus 5884 * @description Returns a boolean indicating whether or not the menu has focus. 5885 * @return {Boolean} 5886 */ 5887 hasFocus: function () { 5888 5889 return (MenuManager.getFocusedMenu() == this.getRoot()); 5890 5891 }, 5892 5893 5894 _doItemSubmenuSubscribe: function (p_sType, p_aArgs, p_oObject) { 5895 5896 var oItem = p_aArgs[0], 5897 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 5898 5899 if (oSubmenu) { 5900 oSubmenu.subscribe.apply(oSubmenu, p_oObject); 5901 } 5902 5903 }, 5904 5905 5906 _doSubmenuSubscribe: function (p_sType, p_aArgs, p_oObject) { 5907 5908 var oSubmenu = this.cfg.getProperty(_SUBMENU); 5909 5910 if (oSubmenu) { 5911 oSubmenu.subscribe.apply(oSubmenu, p_oObject); 5912 } 5913 5914 }, 5915 5916 5917 /** 5918 * Adds the specified CustomEvent subscriber to the menu and each of 5919 * its submenus. 5920 * @method subscribe 5921 * @param p_type {string} the type, or name of the event 5922 * @param p_fn {function} the function to exectute when the event fires 5923 * @param p_obj {Object} An object to be passed along when the event 5924 * fires 5925 * @param p_override {boolean} If true, the obj passed in becomes the 5926 * execution scope of the listener 5927 */ 5928 subscribe: function () { 5929 5930 // Subscribe to the event for this Menu instance 5931 Menu.superclass.subscribe.apply(this, arguments); 5932 5933 // Subscribe to the "itemAdded" event so that all future submenus 5934 // also subscribe to this event 5935 Menu.superclass.subscribe.call(this, _ITEM_ADDED, this._doItemSubmenuSubscribe, arguments); 5936 5937 5938 var aItems = this.getItems(), 5939 nItems, 5940 oItem, 5941 oSubmenu, 5942 i; 5943 5944 5945 if (aItems) { 5946 5947 nItems = aItems.length; 5948 5949 if (nItems > 0) { 5950 5951 i = nItems - 1; 5952 5953 do { 5954 5955 oItem = aItems[i]; 5956 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 5957 5958 if (oSubmenu) { 5959 oSubmenu.subscribe.apply(oSubmenu, arguments); 5960 } 5961 else { 5962 oItem.cfg.subscribeToConfigEvent(_SUBMENU, this._doSubmenuSubscribe, arguments); 5963 } 5964 5965 } 5966 while (i--); 5967 5968 } 5969 5970 } 5971 5972 }, 5973 5974 5975 unsubscribe: function () { 5976 5977 // Remove the event for this Menu instance 5978 Menu.superclass.unsubscribe.apply(this, arguments); 5979 5980 // Remove the "itemAdded" event so that all future submenus don't have 5981 // the event handler 5982 Menu.superclass.unsubscribe.call(this, _ITEM_ADDED, this._doItemSubmenuSubscribe, arguments); 5983 5984 5985 var aItems = this.getItems(), 5986 nItems, 5987 oItem, 5988 oSubmenu, 5989 i; 5990 5991 5992 if (aItems) { 5993 5994 nItems = aItems.length; 5995 5996 if (nItems > 0) { 5997 5998 i = nItems - 1; 5999 6000 do { 6001 6002 oItem = aItems[i]; 6003 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 6004 6005 if (oSubmenu) { 6006 oSubmenu.unsubscribe.apply(oSubmenu, arguments); 6007 } 6008 else { 6009 oItem.cfg.unsubscribeFromConfigEvent(_SUBMENU, this._doSubmenuSubscribe, arguments); 6010 } 6011 6012 } 6013 while (i--); 6014 6015 } 6016 6017 } 6018 6019 }, 6020 6021 6022 /** 6023 * @description Initializes the class's configurable properties which can be 6024 * changed using the menu's Config object ("cfg"). 6025 * @method initDefaultConfig 6026 */ 6027 initDefaultConfig: function () { 6028 6029 Menu.superclass.initDefaultConfig.call(this); 6030 6031 var oConfig = this.cfg; 6032 6033 6034 // Module documentation overrides 6035 6036 /** 6037 * @config effect 6038 * @description Object or array of objects representing the ContainerEffect 6039 * classes that are active for animating the container. When set this 6040 * property is automatically applied to all submenus. 6041 * @type Object 6042 * @default null 6043 */ 6044 6045 // Overlay documentation overrides 6046 6047 6048 /** 6049 * @config x 6050 * @description Number representing the absolute x-coordinate position of 6051 * the Menu. This property is only applied when the "position" 6052 * configuration property is set to dynamic. 6053 * @type Number 6054 * @default null 6055 */ 6056 6057 6058 /** 6059 * @config y 6060 * @description Number representing the absolute y-coordinate position of 6061 * the Menu. This property is only applied when the "position" 6062 * configuration property is set to dynamic. 6063 * @type Number 6064 * @default null 6065 */ 6066 6067 6068 /** 6069 * @description Array of the absolute x and y positions of the Menu. This 6070 * property is only applied when the "position" configuration property is 6071 * set to dynamic. 6072 * @config xy 6073 * @type Number[] 6074 * @default null 6075 */ 6076 6077 6078 /** 6079 * @config context 6080 * @description Array of context arguments for context-sensitive positioning. 6081 * The format is: [id or element, element corner, context corner]. 6082 * For example, setting this property to ["img1", "tl", "bl"] would 6083 * align the Menu's top left corner to the context element's 6084 * bottom left corner. This property is only applied when the "position" 6085 * configuration property is set to dynamic. 6086 * @type Array 6087 * @default null 6088 */ 6089 6090 6091 /** 6092 * @config fixedcenter 6093 * @description Boolean indicating if the Menu should be anchored to the 6094 * center of the viewport. This property is only applied when the 6095 * "position" configuration property is set to dynamic. 6096 * @type Boolean 6097 * @default false 6098 */ 6099 6100 6101 /** 6102 * @config iframe 6103 * @description Boolean indicating whether or not the Menu should 6104 * have an IFRAME shim; used to prevent SELECT elements from 6105 * poking through an Overlay instance in IE6. When set to "true", 6106 * the iframe shim is created when the Menu instance is intially 6107 * made visible. This property is only applied when the "position" 6108 * configuration property is set to dynamic and is automatically applied 6109 * to all submenus. 6110 * @type Boolean 6111 * @default true for IE6 and below, false for all other browsers. 6112 */ 6113 6114 6115 // Add configuration attributes 6116 6117 /* 6118 Change the default value for the "visible" configuration 6119 property to "false" by re-adding the property. 6120 */ 6121 6122 /** 6123 * @config visible 6124 * @description Boolean indicating whether or not the menu is visible. If 6125 * the menu's "position" configuration property is set to "dynamic" (the 6126 * default), this property toggles the menu's <code><div></code> 6127 * element's "visibility" style property between "visible" (true) or 6128 * "hidden" (false). If the menu's "position" configuration property is 6129 * set to "static" this property toggles the menu's 6130 * <code><div></code> element's "display" style property 6131 * between "block" (true) or "none" (false). 6132 * @default false 6133 * @type Boolean 6134 */ 6135 oConfig.addProperty( 6136 VISIBLE_CONFIG.key, 6137 { 6138 handler: this.configVisible, 6139 value: VISIBLE_CONFIG.value, 6140 validator: VISIBLE_CONFIG.validator 6141 } 6142 ); 6143 6144 6145 /* 6146 Change the default value for the "constraintoviewport" configuration 6147 property (inherited by YAHOO.widget.Overlay) to "true" by re-adding the property. 6148 */ 6149 6150 /** 6151 * @config constraintoviewport 6152 * @description Boolean indicating if the menu will try to remain inside 6153 * the boundaries of the size of viewport. This property is only applied 6154 * when the "position" configuration property is set to dynamic and is 6155 * automatically applied to all submenus. 6156 * @default true 6157 * @type Boolean 6158 */ 6159 oConfig.addProperty( 6160 CONSTRAIN_TO_VIEWPORT_CONFIG.key, 6161 { 6162 handler: this.configConstrainToViewport, 6163 value: CONSTRAIN_TO_VIEWPORT_CONFIG.value, 6164 validator: CONSTRAIN_TO_VIEWPORT_CONFIG.validator, 6165 supercedes: CONSTRAIN_TO_VIEWPORT_CONFIG.supercedes 6166 } 6167 ); 6168 6169 6170 /* 6171 Change the default value for the "preventcontextoverlap" configuration 6172 property (inherited by YAHOO.widget.Overlay) to "true" by re-adding the property. 6173 */ 6174 6175 /** 6176 * @config preventcontextoverlap 6177 * @description Boolean indicating whether or not a submenu should overlap its parent MenuItem 6178 * when the "constraintoviewport" configuration property is set to "true". 6179 * @type Boolean 6180 * @default true 6181 */ 6182 oConfig.addProperty(PREVENT_CONTEXT_OVERLAP_CONFIG.key, { 6183 6184 value: PREVENT_CONTEXT_OVERLAP_CONFIG.value, 6185 validator: PREVENT_CONTEXT_OVERLAP_CONFIG.validator, 6186 supercedes: PREVENT_CONTEXT_OVERLAP_CONFIG.supercedes 6187 6188 }); 6189 6190 6191 /** 6192 * @config position 6193 * @description String indicating how a menu should be positioned on the 6194 * screen. Possible values are "static" and "dynamic." Static menus are 6195 * visible by default and reside in the normal flow of the document 6196 * (CSS position: static). Dynamic menus are hidden by default, reside 6197 * out of the normal flow of the document (CSS position: absolute), and 6198 * can overlay other elements on the screen. 6199 * @default dynamic 6200 * @type String 6201 */ 6202 oConfig.addProperty( 6203 POSITION_CONFIG.key, 6204 { 6205 handler: this.configPosition, 6206 value: POSITION_CONFIG.value, 6207 validator: POSITION_CONFIG.validator, 6208 supercedes: POSITION_CONFIG.supercedes 6209 } 6210 ); 6211 6212 6213 /** 6214 * @config submenualignment 6215 * @description Array defining how submenus should be aligned to their 6216 * parent menu item. The format is: [itemCorner, submenuCorner]. By default 6217 * a submenu's top left corner is aligned to its parent menu item's top 6218 * right corner. 6219 * @default ["tl","tr"] 6220 * @type Array 6221 */ 6222 oConfig.addProperty( 6223 SUBMENU_ALIGNMENT_CONFIG.key, 6224 { 6225 value: SUBMENU_ALIGNMENT_CONFIG.value, 6226 suppressEvent: SUBMENU_ALIGNMENT_CONFIG.suppressEvent 6227 } 6228 ); 6229 6230 6231 /** 6232 * @config autosubmenudisplay 6233 * @description Boolean indicating if submenus are automatically made 6234 * visible when the user mouses over the menu's items. 6235 * @default true 6236 * @type Boolean 6237 */ 6238 oConfig.addProperty( 6239 AUTO_SUBMENU_DISPLAY_CONFIG.key, 6240 { 6241 value: AUTO_SUBMENU_DISPLAY_CONFIG.value, 6242 validator: AUTO_SUBMENU_DISPLAY_CONFIG.validator, 6243 suppressEvent: AUTO_SUBMENU_DISPLAY_CONFIG.suppressEvent 6244 } 6245 ); 6246 6247 6248 /** 6249 * @config showdelay 6250 * @description Number indicating the time (in milliseconds) that should 6251 * expire before a submenu is made visible when the user mouses over 6252 * the menu's items. This property is only applied when the "position" 6253 * configuration property is set to dynamic and is automatically applied 6254 * to all submenus. 6255 * @default 250 6256 * @type Number 6257 */ 6258 oConfig.addProperty( 6259 SHOW_DELAY_CONFIG.key, 6260 { 6261 value: SHOW_DELAY_CONFIG.value, 6262 validator: SHOW_DELAY_CONFIG.validator, 6263 suppressEvent: SHOW_DELAY_CONFIG.suppressEvent 6264 } 6265 ); 6266 6267 6268 /** 6269 * @config hidedelay 6270 * @description Number indicating the time (in milliseconds) that should 6271 * expire before the menu is hidden. This property is only applied when 6272 * the "position" configuration property is set to dynamic and is 6273 * automatically applied to all submenus. 6274 * @default 0 6275 * @type Number 6276 */ 6277 oConfig.addProperty( 6278 HIDE_DELAY_CONFIG.key, 6279 { 6280 handler: this.configHideDelay, 6281 value: HIDE_DELAY_CONFIG.value, 6282 validator: HIDE_DELAY_CONFIG.validator, 6283 suppressEvent: HIDE_DELAY_CONFIG.suppressEvent 6284 } 6285 ); 6286 6287 6288 /** 6289 * @config submenuhidedelay 6290 * @description Number indicating the time (in milliseconds) that should 6291 * expire before a submenu is hidden when the user mouses out of a menu item 6292 * heading in the direction of a submenu. The value must be greater than or 6293 * equal to the value specified for the "showdelay" configuration property. 6294 * This property is only applied when the "position" configuration property 6295 * is set to dynamic and is automatically applied to all submenus. 6296 * @default 250 6297 * @type Number 6298 */ 6299 oConfig.addProperty( 6300 SUBMENU_HIDE_DELAY_CONFIG.key, 6301 { 6302 value: SUBMENU_HIDE_DELAY_CONFIG.value, 6303 validator: SUBMENU_HIDE_DELAY_CONFIG.validator, 6304 suppressEvent: SUBMENU_HIDE_DELAY_CONFIG.suppressEvent 6305 } 6306 ); 6307 6308 6309 /** 6310 * @config clicktohide 6311 * @description Boolean indicating if the menu will automatically be 6312 * hidden if the user clicks outside of it. This property is only 6313 * applied when the "position" configuration property is set to dynamic 6314 * and is automatically applied to all submenus. 6315 * @default true 6316 * @type Boolean 6317 */ 6318 oConfig.addProperty( 6319 CLICK_TO_HIDE_CONFIG.key, 6320 { 6321 value: CLICK_TO_HIDE_CONFIG.value, 6322 validator: CLICK_TO_HIDE_CONFIG.validator, 6323 suppressEvent: CLICK_TO_HIDE_CONFIG.suppressEvent 6324 } 6325 ); 6326 6327 6328 /** 6329 * @config container 6330 * @description HTML element reference or string specifying the id 6331 * attribute of the HTML element that the menu's markup should be 6332 * rendered into. 6333 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 6334 * level-one-html.html#ID-58190037">HTMLElement</a>|String 6335 * @default document.body 6336 */ 6337 oConfig.addProperty( 6338 CONTAINER_CONFIG.key, 6339 { 6340 handler: this.configContainer, 6341 value: document.body, 6342 suppressEvent: CONTAINER_CONFIG.suppressEvent 6343 } 6344 ); 6345 6346 6347 /** 6348 * @config scrollincrement 6349 * @description Number used to control the scroll speed of a menu. Used to 6350 * increment the "scrollTop" property of the menu's body by when a menu's 6351 * content is scrolling. When set this property is automatically applied 6352 * to all submenus. 6353 * @default 1 6354 * @type Number 6355 */ 6356 oConfig.addProperty( 6357 SCROLL_INCREMENT_CONFIG.key, 6358 { 6359 value: SCROLL_INCREMENT_CONFIG.value, 6360 validator: SCROLL_INCREMENT_CONFIG.validator, 6361 supercedes: SCROLL_INCREMENT_CONFIG.supercedes, 6362 suppressEvent: SCROLL_INCREMENT_CONFIG.suppressEvent 6363 } 6364 ); 6365 6366 6367 /** 6368 * @config minscrollheight 6369 * @description Number defining the minimum threshold for the "maxheight" 6370 * configuration property. When set this property is automatically applied 6371 * to all submenus. 6372 * @default 90 6373 * @type Number 6374 */ 6375 oConfig.addProperty( 6376 MIN_SCROLL_HEIGHT_CONFIG.key, 6377 { 6378 value: MIN_SCROLL_HEIGHT_CONFIG.value, 6379 validator: MIN_SCROLL_HEIGHT_CONFIG.validator, 6380 supercedes: MIN_SCROLL_HEIGHT_CONFIG.supercedes, 6381 suppressEvent: MIN_SCROLL_HEIGHT_CONFIG.suppressEvent 6382 } 6383 ); 6384 6385 6386 /** 6387 * @config maxheight 6388 * @description Number defining the maximum height (in pixels) for a menu's 6389 * body element (<code><div class="bd"></code>). Once a menu's body 6390 * exceeds this height, the contents of the body are scrolled to maintain 6391 * this value. This value cannot be set lower than the value of the 6392 * "minscrollheight" configuration property. 6393 * @default 0 6394 * @type Number 6395 */ 6396 oConfig.addProperty( 6397 MAX_HEIGHT_CONFIG.key, 6398 { 6399 handler: this.configMaxHeight, 6400 value: MAX_HEIGHT_CONFIG.value, 6401 validator: MAX_HEIGHT_CONFIG.validator, 6402 suppressEvent: MAX_HEIGHT_CONFIG.suppressEvent, 6403 supercedes: MAX_HEIGHT_CONFIG.supercedes 6404 } 6405 ); 6406 6407 6408 /** 6409 * @config classname 6410 * @description String representing the CSS class to be applied to the 6411 * menu's root <code><div></code> element. The specified class(es) 6412 * are appended in addition to the default class as specified by the menu's 6413 * CSS_CLASS_NAME constant. When set this property is automatically 6414 * applied to all submenus. 6415 * @default null 6416 * @type String 6417 */ 6418 oConfig.addProperty( 6419 CLASS_NAME_CONFIG.key, 6420 { 6421 handler: this.configClassName, 6422 value: CLASS_NAME_CONFIG.value, 6423 validator: CLASS_NAME_CONFIG.validator, 6424 supercedes: CLASS_NAME_CONFIG.supercedes 6425 } 6426 ); 6427 6428 6429 /** 6430 * @config disabled 6431 * @description Boolean indicating if the menu should be disabled. 6432 * Disabling a menu disables each of its items. (Disabled menu items are 6433 * dimmed and will not respond to user input or fire events.) Disabled 6434 * menus have a corresponding "disabled" CSS class applied to their root 6435 * <code><div></code> element. 6436 * @default false 6437 * @type Boolean 6438 */ 6439 oConfig.addProperty( 6440 DISABLED_CONFIG.key, 6441 { 6442 handler: this.configDisabled, 6443 value: DISABLED_CONFIG.value, 6444 validator: DISABLED_CONFIG.validator, 6445 suppressEvent: DISABLED_CONFIG.suppressEvent 6446 } 6447 ); 6448 6449 6450 /** 6451 * @config shadow 6452 * @description Boolean indicating if the menu should have a shadow. 6453 * @default true 6454 * @type Boolean 6455 */ 6456 oConfig.addProperty( 6457 SHADOW_CONFIG.key, 6458 { 6459 handler: this.configShadow, 6460 value: SHADOW_CONFIG.value, 6461 validator: SHADOW_CONFIG.validator 6462 } 6463 ); 6464 6465 6466 /** 6467 * @config keepopen 6468 * @description Boolean indicating if the menu should remain open when clicked. 6469 * @default false 6470 * @type Boolean 6471 */ 6472 oConfig.addProperty( 6473 KEEP_OPEN_CONFIG.key, 6474 { 6475 value: KEEP_OPEN_CONFIG.value, 6476 validator: KEEP_OPEN_CONFIG.validator 6477 } 6478 ); 6479 6480 } 6481 6482 }); // END YAHOO.lang.extend 6483 6484 })(); 6485 6486 6487 6488 (function () { 6489 6490 /** 6491 * Creates an item for a menu. 6492 * 6493 * @param {HTML} p_oObject Markup for the menu item content. The markup is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 6494 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6495 * one-html.html#ID-74680021">HTMLLIElement</a>} p_oObject Object specifying 6496 * the <code><li></code> element of the menu item. 6497 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6498 * one-html.html#ID-38450247">HTMLOptGroupElement</a>} p_oObject Object 6499 * specifying the <code><optgroup></code> element of the menu item. 6500 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6501 * one-html.html#ID-70901257">HTMLOptionElement</a>} p_oObject Object 6502 * specifying the <code><option></code> element of the menu item. 6503 * @param {Object} p_oConfig Optional. Object literal specifying the 6504 * configuration for the menu item. See configuration class documentation 6505 * for more details. 6506 * @class MenuItem 6507 * @constructor 6508 */ 6509 YAHOO.widget.MenuItem = function (p_oObject, p_oConfig) { 6510 6511 if (p_oObject) { 6512 6513 if (p_oConfig) { 6514 6515 this.parent = p_oConfig.parent; 6516 this.value = p_oConfig.value; 6517 this.id = p_oConfig.id; 6518 6519 } 6520 6521 this.init(p_oObject, p_oConfig); 6522 6523 } 6524 6525 }; 6526 6527 6528 var Dom = YAHOO.util.Dom, 6529 Module = YAHOO.widget.Module, 6530 Menu = YAHOO.widget.Menu, 6531 MenuItem = YAHOO.widget.MenuItem, 6532 CustomEvent = YAHOO.util.CustomEvent, 6533 UA = YAHOO.env.ua, 6534 Lang = YAHOO.lang, 6535 6536 // Private string constants 6537 6538 _TEXT = "text", 6539 _HASH = "#", 6540 _HYPHEN = "-", 6541 _HELP_TEXT = "helptext", 6542 _URL = "url", 6543 _TARGET = "target", 6544 _EMPHASIS = "emphasis", 6545 _STRONG_EMPHASIS = "strongemphasis", 6546 _CHECKED = "checked", 6547 _SUBMENU = "submenu", 6548 _DISABLED = "disabled", 6549 _SELECTED = "selected", 6550 _HAS_SUBMENU = "hassubmenu", 6551 _CHECKED_DISABLED = "checked-disabled", 6552 _HAS_SUBMENU_DISABLED = "hassubmenu-disabled", 6553 _HAS_SUBMENU_SELECTED = "hassubmenu-selected", 6554 _CHECKED_SELECTED = "checked-selected", 6555 _ONCLICK = "onclick", 6556 _CLASSNAME = "classname", 6557 _EMPTY_STRING = "", 6558 _OPTION = "OPTION", 6559 _OPTGROUP = "OPTGROUP", 6560 _LI_UPPERCASE = "LI", 6561 _HREF = "href", 6562 _SELECT = "SELECT", 6563 _DIV = "DIV", 6564 _START_HELP_TEXT = "<em class=\"helptext\">", 6565 _START_EM = "<em>", 6566 _END_EM = "</em>", 6567 _START_STRONG = "<strong>", 6568 _END_STRONG = "</strong>", 6569 _PREVENT_CONTEXT_OVERLAP = "preventcontextoverlap", 6570 _OBJ = "obj", 6571 _SCOPE = "scope", 6572 _NONE = "none", 6573 _VISIBLE = "visible", 6574 _SPACE = " ", 6575 _MENUITEM = "MenuItem", 6576 _CLICK = "click", 6577 _SHOW = "show", 6578 _HIDE = "hide", 6579 _LI_LOWERCASE = "li", 6580 _ANCHOR_TEMPLATE = "<a href=\"#\"></a>", 6581 6582 EVENT_TYPES = [ 6583 6584 ["mouseOverEvent", "mouseover"], 6585 ["mouseOutEvent", "mouseout"], 6586 ["mouseDownEvent", "mousedown"], 6587 ["mouseUpEvent", "mouseup"], 6588 ["clickEvent", _CLICK], 6589 ["keyPressEvent", "keypress"], 6590 ["keyDownEvent", "keydown"], 6591 ["keyUpEvent", "keyup"], 6592 ["focusEvent", "focus"], 6593 ["blurEvent", "blur"], 6594 ["destroyEvent", "destroy"] 6595 6596 ], 6597 6598 TEXT_CONFIG = { 6599 key: _TEXT, 6600 value: _EMPTY_STRING, 6601 validator: Lang.isString, 6602 suppressEvent: true 6603 }, 6604 6605 HELP_TEXT_CONFIG = { 6606 key: _HELP_TEXT, 6607 supercedes: [_TEXT], 6608 suppressEvent: true 6609 }, 6610 6611 URL_CONFIG = { 6612 key: _URL, 6613 value: _HASH, 6614 suppressEvent: true 6615 }, 6616 6617 TARGET_CONFIG = { 6618 key: _TARGET, 6619 suppressEvent: true 6620 }, 6621 6622 EMPHASIS_CONFIG = { 6623 key: _EMPHASIS, 6624 value: false, 6625 validator: Lang.isBoolean, 6626 suppressEvent: true, 6627 supercedes: [_TEXT] 6628 }, 6629 6630 STRONG_EMPHASIS_CONFIG = { 6631 key: _STRONG_EMPHASIS, 6632 value: false, 6633 validator: Lang.isBoolean, 6634 suppressEvent: true, 6635 supercedes: [_TEXT] 6636 }, 6637 6638 CHECKED_CONFIG = { 6639 key: _CHECKED, 6640 value: false, 6641 validator: Lang.isBoolean, 6642 suppressEvent: true, 6643 supercedes: [_DISABLED, _SELECTED] 6644 }, 6645 6646 SUBMENU_CONFIG = { 6647 key: _SUBMENU, 6648 suppressEvent: true, 6649 supercedes: [_DISABLED, _SELECTED] 6650 }, 6651 6652 DISABLED_CONFIG = { 6653 key: _DISABLED, 6654 value: false, 6655 validator: Lang.isBoolean, 6656 suppressEvent: true, 6657 supercedes: [_TEXT, _SELECTED] 6658 }, 6659 6660 SELECTED_CONFIG = { 6661 key: _SELECTED, 6662 value: false, 6663 validator: Lang.isBoolean, 6664 suppressEvent: true 6665 }, 6666 6667 ONCLICK_CONFIG = { 6668 key: _ONCLICK, 6669 suppressEvent: true 6670 }, 6671 6672 CLASS_NAME_CONFIG = { 6673 key: _CLASSNAME, 6674 value: null, 6675 validator: Lang.isString, 6676 suppressEvent: true 6677 }, 6678 6679 KEY_LISTENER_CONFIG = { 6680 key: "keylistener", 6681 value: null, 6682 suppressEvent: true 6683 }, 6684 6685 m_oMenuItemTemplate = null, 6686 6687 CLASS_NAMES = {}; 6688 6689 6690 /** 6691 * @method getClassNameForState 6692 * @description Returns a class name for the specified prefix and state. If the class name does not 6693 * yet exist, it is created and stored in the CLASS_NAMES object to increase performance. 6694 * @private 6695 * @param {String} prefix String representing the prefix for the class name 6696 * @param {String} state String representing a state - "disabled," "checked," etc. 6697 */ 6698 var getClassNameForState = function (prefix, state) { 6699 6700 var oClassNames = CLASS_NAMES[prefix]; 6701 6702 if (!oClassNames) { 6703 CLASS_NAMES[prefix] = {}; 6704 oClassNames = CLASS_NAMES[prefix]; 6705 } 6706 6707 6708 var sClassName = oClassNames[state]; 6709 6710 if (!sClassName) { 6711 sClassName = prefix + _HYPHEN + state; 6712 oClassNames[state] = sClassName; 6713 } 6714 6715 return sClassName; 6716 6717 }; 6718 6719 6720 /** 6721 * @method addClassNameForState 6722 * @description Applies a class name to a MenuItem instance's <LI> and <A> elements 6723 * that represents a MenuItem's state - "disabled," "checked," etc. 6724 * @private 6725 * @param {String} state String representing a state - "disabled," "checked," etc. 6726 */ 6727 var addClassNameForState = function (state) { 6728 6729 Dom.addClass(this.element, getClassNameForState(this.CSS_CLASS_NAME, state)); 6730 Dom.addClass(this._oAnchor, getClassNameForState(this.CSS_LABEL_CLASS_NAME, state)); 6731 6732 }; 6733 6734 /** 6735 * @method removeClassNameForState 6736 * @description Removes a class name from a MenuItem instance's <LI> and <A> elements 6737 * that represents a MenuItem's state - "disabled," "checked," etc. 6738 * @private 6739 * @param {String} state String representing a state - "disabled," "checked," etc. 6740 */ 6741 var removeClassNameForState = function (state) { 6742 6743 Dom.removeClass(this.element, getClassNameForState(this.CSS_CLASS_NAME, state)); 6744 Dom.removeClass(this._oAnchor, getClassNameForState(this.CSS_LABEL_CLASS_NAME, state)); 6745 6746 }; 6747 6748 6749 MenuItem.prototype = { 6750 6751 /** 6752 * @property CSS_CLASS_NAME 6753 * @description String representing the CSS class(es) to be applied to the 6754 * <code><li></code> element of the menu item. 6755 * @default "yuimenuitem" 6756 * @final 6757 * @type String 6758 */ 6759 CSS_CLASS_NAME: "yuimenuitem", 6760 6761 6762 /** 6763 * @property CSS_LABEL_CLASS_NAME 6764 * @description String representing the CSS class(es) to be applied to the 6765 * menu item's <code><a></code> element. 6766 * @default "yuimenuitemlabel" 6767 * @final 6768 * @type String 6769 */ 6770 CSS_LABEL_CLASS_NAME: "yuimenuitemlabel", 6771 6772 6773 /** 6774 * @property SUBMENU_TYPE 6775 * @description Object representing the type of menu to instantiate and 6776 * add when parsing the child nodes of the menu item's source HTML element. 6777 * @final 6778 * @type YAHOO.widget.Menu 6779 */ 6780 SUBMENU_TYPE: null, 6781 6782 6783 6784 // Private member variables 6785 6786 6787 /** 6788 * @property _oAnchor 6789 * @description Object reference to the menu item's 6790 * <code><a></code> element. 6791 * @default null 6792 * @private 6793 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6794 * one-html.html#ID-48250443">HTMLAnchorElement</a> 6795 */ 6796 _oAnchor: null, 6797 6798 6799 /** 6800 * @property _oHelpTextEM 6801 * @description Object reference to the menu item's help text 6802 * <code><em></code> element. 6803 * @default null 6804 * @private 6805 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6806 * one-html.html#ID-58190037">HTMLElement</a> 6807 */ 6808 _oHelpTextEM: null, 6809 6810 6811 /** 6812 * @property _oSubmenu 6813 * @description Object reference to the menu item's submenu. 6814 * @default null 6815 * @private 6816 * @type YAHOO.widget.Menu 6817 */ 6818 _oSubmenu: null, 6819 6820 6821 /** 6822 * @property _oOnclickAttributeValue 6823 * @description Object reference to the menu item's current value for the 6824 * "onclick" configuration attribute. 6825 * @default null 6826 * @private 6827 * @type Object 6828 */ 6829 _oOnclickAttributeValue: null, 6830 6831 6832 /** 6833 * @property _sClassName 6834 * @description The current value of the "classname" configuration attribute. 6835 * @default null 6836 * @private 6837 * @type String 6838 */ 6839 _sClassName: null, 6840 6841 6842 6843 // Public properties 6844 6845 6846 /** 6847 * @property constructor 6848 * @description Object reference to the menu item's constructor function. 6849 * @default YAHOO.widget.MenuItem 6850 * @type YAHOO.widget.MenuItem 6851 */ 6852 constructor: MenuItem, 6853 6854 6855 /** 6856 * @property index 6857 * @description Number indicating the ordinal position of the menu item in 6858 * its group. 6859 * @default null 6860 * @type Number 6861 */ 6862 index: null, 6863 6864 6865 /** 6866 * @property groupIndex 6867 * @description Number indicating the index of the group to which the menu 6868 * item belongs. 6869 * @default null 6870 * @type Number 6871 */ 6872 groupIndex: null, 6873 6874 6875 /** 6876 * @property parent 6877 * @description Object reference to the menu item's parent menu. 6878 * @default null 6879 * @type YAHOO.widget.Menu 6880 */ 6881 parent: null, 6882 6883 6884 /** 6885 * @property element 6886 * @description Object reference to the menu item's 6887 * <code><li></code> element. 6888 * @default <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level 6889 * -one-html.html#ID-74680021">HTMLLIElement</a> 6890 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6891 * one-html.html#ID-74680021">HTMLLIElement</a> 6892 */ 6893 element: null, 6894 6895 6896 /** 6897 * @property srcElement 6898 * @description Object reference to the HTML element (either 6899 * <code><li></code>, <code><optgroup></code> or 6900 * <code><option></code>) used create the menu item. 6901 * @default <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 6902 * level-one-html.html#ID-74680021">HTMLLIElement</a>|<a href="http://www. 6903 * w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-html.html#ID-38450247" 6904 * >HTMLOptGroupElement</a>|<a href="http://www.w3.org/TR/2000/WD-DOM- 6905 * Level-1-20000929/level-one-html.html#ID-70901257">HTMLOptionElement</a> 6906 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 6907 * one-html.html#ID-74680021">HTMLLIElement</a>|<a href="http://www.w3. 6908 * org/TR/2000/WD-DOM-Level-1-20000929/level-one-html.html#ID-38450247"> 6909 * HTMLOptGroupElement</a>|<a href="http://www.w3.org/TR/2000/WD-DOM- 6910 * Level-1-20000929/level-one-html.html#ID-70901257">HTMLOptionElement</a> 6911 */ 6912 srcElement: null, 6913 6914 6915 /** 6916 * @property value 6917 * @description Object reference to the menu item's value. 6918 * @default null 6919 * @type Object 6920 */ 6921 value: null, 6922 6923 6924 /** 6925 * @property browser 6926 * @deprecated Use YAHOO.env.ua 6927 * @description String representing the browser. 6928 * @type String 6929 */ 6930 browser: Module.prototype.browser, 6931 6932 6933 /** 6934 * @property id 6935 * @description Id of the menu item's root <code><li></code> 6936 * element. This property should be set via the constructor using the 6937 * configuration object literal. If an id is not specified, then one will 6938 * be created using the "generateId" method of the Dom utility. 6939 * @default null 6940 * @type String 6941 */ 6942 id: null, 6943 6944 6945 6946 // Events 6947 6948 6949 /** 6950 * @event destroyEvent 6951 * @description Fires when the menu item's <code><li></code> 6952 * element is removed from its parent <code><ul></code> element. 6953 * @type YAHOO.util.CustomEvent 6954 */ 6955 6956 6957 /** 6958 * @event mouseOverEvent 6959 * @description Fires when the mouse has entered the menu item. Passes 6960 * back the DOM Event object as an argument. 6961 * @type YAHOO.util.CustomEvent 6962 */ 6963 6964 6965 /** 6966 * @event mouseOutEvent 6967 * @description Fires when the mouse has left the menu item. Passes back 6968 * the DOM Event object as an argument. 6969 * @type YAHOO.util.CustomEvent 6970 */ 6971 6972 6973 /** 6974 * @event mouseDownEvent 6975 * @description Fires when the user mouses down on the menu item. Passes 6976 * back the DOM Event object as an argument. 6977 * @type YAHOO.util.CustomEvent 6978 */ 6979 6980 6981 /** 6982 * @event mouseUpEvent 6983 * @description Fires when the user releases a mouse button while the mouse 6984 * is over the menu item. Passes back the DOM Event object as an argument. 6985 * @type YAHOO.util.CustomEvent 6986 */ 6987 6988 6989 /** 6990 * @event clickEvent 6991 * @description Fires when the user clicks the on the menu item. Passes 6992 * back the DOM Event object as an argument. 6993 * @type YAHOO.util.CustomEvent 6994 */ 6995 6996 6997 /** 6998 * @event keyPressEvent 6999 * @description Fires when the user presses an alphanumeric key when the 7000 * menu item has focus. Passes back the DOM Event object as an argument. 7001 * @type YAHOO.util.CustomEvent 7002 */ 7003 7004 7005 /** 7006 * @event keyDownEvent 7007 * @description Fires when the user presses a key when the menu item has 7008 * focus. Passes back the DOM Event object as an argument. 7009 * @type YAHOO.util.CustomEvent 7010 */ 7011 7012 7013 /** 7014 * @event keyUpEvent 7015 * @description Fires when the user releases a key when the menu item has 7016 * focus. Passes back the DOM Event object as an argument. 7017 * @type YAHOO.util.CustomEvent 7018 */ 7019 7020 7021 /** 7022 * @event focusEvent 7023 * @description Fires when the menu item receives focus. 7024 * @type YAHOO.util.CustomEvent 7025 */ 7026 7027 7028 /** 7029 * @event blurEvent 7030 * @description Fires when the menu item loses the input focus. 7031 * @type YAHOO.util.CustomEvent 7032 */ 7033 7034 7035 /** 7036 * @method init 7037 * @description The MenuItem class's initialization method. This method is 7038 * automatically called by the constructor, and sets up all DOM references 7039 * for pre-existing markup, and creates required markup if it is not 7040 * already present. 7041 * @param {HTML} p_oObject Markup for the menu item content. The markup is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 7042 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 7043 * one-html.html#ID-74680021">HTMLLIElement</a>} p_oObject Object specifying 7044 * the <code><li></code> element of the menu item. 7045 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 7046 * one-html.html#ID-38450247">HTMLOptGroupElement</a>} p_oObject Object 7047 * specifying the <code><optgroup></code> element of the menu item. 7048 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 7049 * one-html.html#ID-70901257">HTMLOptionElement</a>} p_oObject Object 7050 * specifying the <code><option></code> element of the menu item. 7051 * @param {Object} p_oConfig Optional. Object literal specifying the 7052 * configuration for the menu item. See configuration class documentation 7053 * for more details. 7054 */ 7055 init: function (p_oObject, p_oConfig) { 7056 7057 7058 if (!this.SUBMENU_TYPE) { 7059 7060 this.SUBMENU_TYPE = Menu; 7061 7062 } 7063 7064 7065 // Create the config object 7066 7067 this.cfg = new YAHOO.util.Config(this); 7068 7069 this.initDefaultConfig(); 7070 7071 var oConfig = this.cfg, 7072 sURL = _HASH, 7073 oCustomEvent, 7074 aEventData, 7075 oAnchor, 7076 sTarget, 7077 sText, 7078 sId, 7079 i; 7080 7081 7082 if (Lang.isString(p_oObject)) { 7083 7084 this._createRootNodeStructure(); 7085 7086 oConfig.queueProperty(_TEXT, p_oObject); 7087 7088 } 7089 else if (p_oObject && p_oObject.tagName) { 7090 7091 switch(p_oObject.tagName.toUpperCase()) { 7092 7093 case _OPTION: 7094 7095 this._createRootNodeStructure(); 7096 7097 oConfig.queueProperty(_TEXT, p_oObject.text); 7098 oConfig.queueProperty(_DISABLED, p_oObject.disabled); 7099 7100 this.value = p_oObject.value; 7101 7102 this.srcElement = p_oObject; 7103 7104 break; 7105 7106 case _OPTGROUP: 7107 7108 this._createRootNodeStructure(); 7109 7110 oConfig.queueProperty(_TEXT, p_oObject.label); 7111 oConfig.queueProperty(_DISABLED, p_oObject.disabled); 7112 7113 this.srcElement = p_oObject; 7114 7115 this._initSubTree(); 7116 7117 break; 7118 7119 case _LI_UPPERCASE: 7120 7121 // Get the anchor node (if it exists) 7122 7123 oAnchor = Dom.getFirstChild(p_oObject); 7124 7125 7126 // Capture the "text" and/or the "URL" 7127 7128 if (oAnchor) { 7129 7130 sURL = oAnchor.getAttribute(_HREF, 2); 7131 sTarget = oAnchor.getAttribute(_TARGET); 7132 7133 sText = oAnchor.innerHTML; 7134 7135 } 7136 7137 this.srcElement = p_oObject; 7138 this.element = p_oObject; 7139 this._oAnchor = oAnchor; 7140 7141 /* 7142 Set these properties silently to sync up the 7143 configuration object without making changes to the 7144 element's DOM 7145 */ 7146 7147 oConfig.setProperty(_TEXT, sText, true); 7148 oConfig.setProperty(_URL, sURL, true); 7149 oConfig.setProperty(_TARGET, sTarget, true); 7150 7151 this._initSubTree(); 7152 7153 break; 7154 7155 } 7156 7157 } 7158 7159 7160 if (this.element) { 7161 7162 sId = (this.srcElement || this.element).id; 7163 7164 if (!sId) { 7165 7166 sId = this.id || Dom.generateId(); 7167 7168 this.element.id = sId; 7169 7170 } 7171 7172 this.id = sId; 7173 7174 7175 Dom.addClass(this.element, this.CSS_CLASS_NAME); 7176 Dom.addClass(this._oAnchor, this.CSS_LABEL_CLASS_NAME); 7177 7178 7179 i = EVENT_TYPES.length - 1; 7180 7181 do { 7182 7183 aEventData = EVENT_TYPES[i]; 7184 7185 oCustomEvent = this.createEvent(aEventData[1]); 7186 oCustomEvent.signature = CustomEvent.LIST; 7187 7188 this[aEventData[0]] = oCustomEvent; 7189 7190 } 7191 while (i--); 7192 7193 7194 if (p_oConfig) { 7195 7196 oConfig.applyConfig(p_oConfig); 7197 7198 } 7199 7200 oConfig.fireQueue(); 7201 7202 } 7203 7204 }, 7205 7206 7207 7208 // Private methods 7209 7210 /** 7211 * @method _createRootNodeStructure 7212 * @description Creates the core DOM structure for the menu item. 7213 * @private 7214 */ 7215 _createRootNodeStructure: function () { 7216 7217 var oElement, 7218 oAnchor; 7219 7220 if (!m_oMenuItemTemplate) { 7221 7222 m_oMenuItemTemplate = document.createElement(_LI_LOWERCASE); 7223 m_oMenuItemTemplate.innerHTML = _ANCHOR_TEMPLATE; 7224 7225 } 7226 7227 oElement = m_oMenuItemTemplate.cloneNode(true); 7228 oElement.className = this.CSS_CLASS_NAME; 7229 7230 oAnchor = oElement.firstChild; 7231 oAnchor.className = this.CSS_LABEL_CLASS_NAME; 7232 7233 this.element = oElement; 7234 this._oAnchor = oAnchor; 7235 7236 }, 7237 7238 7239 /** 7240 * @method _initSubTree 7241 * @description Iterates the source element's childNodes collection and uses 7242 * the child nodes to instantiate other menus. 7243 * @private 7244 */ 7245 _initSubTree: function () { 7246 7247 var oSrcEl = this.srcElement, 7248 oConfig = this.cfg, 7249 oNode, 7250 aOptions, 7251 nOptions, 7252 oMenu, 7253 n; 7254 7255 7256 if (oSrcEl.childNodes.length > 0) { 7257 7258 if (this.parent.lazyLoad && this.parent.srcElement && 7259 this.parent.srcElement.tagName.toUpperCase() == _SELECT) { 7260 7261 oConfig.setProperty( 7262 _SUBMENU, 7263 { id: Dom.generateId(), itemdata: oSrcEl.childNodes } 7264 ); 7265 7266 } 7267 else { 7268 7269 oNode = oSrcEl.firstChild; 7270 aOptions = []; 7271 7272 do { 7273 7274 if (oNode && oNode.tagName) { 7275 7276 switch(oNode.tagName.toUpperCase()) { 7277 7278 case _DIV: 7279 7280 oConfig.setProperty(_SUBMENU, oNode); 7281 7282 break; 7283 7284 case _OPTION: 7285 7286 aOptions[aOptions.length] = oNode; 7287 7288 break; 7289 7290 } 7291 7292 } 7293 7294 } 7295 while((oNode = oNode.nextSibling)); 7296 7297 7298 nOptions = aOptions.length; 7299 7300 if (nOptions > 0) { 7301 7302 oMenu = new this.SUBMENU_TYPE(Dom.generateId()); 7303 7304 oConfig.setProperty(_SUBMENU, oMenu); 7305 7306 for(n=0; n<nOptions; n++) { 7307 7308 oMenu.addItem((new oMenu.ITEM_TYPE(aOptions[n]))); 7309 7310 } 7311 7312 } 7313 7314 } 7315 7316 } 7317 7318 }, 7319 7320 7321 7322 // Event handlers for configuration properties 7323 7324 7325 /** 7326 * @method configText 7327 * @description Event handler for when the "text" configuration property of 7328 * the menu item changes. 7329 * @param {String} p_sType String representing the name of the event that 7330 * was fired. 7331 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7332 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7333 * that fired the event. 7334 */ 7335 configText: function (p_sType, p_aArgs, p_oItem) { 7336 7337 var sText = p_aArgs[0], 7338 oConfig = this.cfg, 7339 oAnchor = this._oAnchor, 7340 sHelpText = oConfig.getProperty(_HELP_TEXT), 7341 sHelpTextHTML = _EMPTY_STRING, 7342 sEmphasisStartTag = _EMPTY_STRING, 7343 sEmphasisEndTag = _EMPTY_STRING; 7344 7345 7346 if (sText) { 7347 7348 7349 if (sHelpText) { 7350 7351 sHelpTextHTML = _START_HELP_TEXT + sHelpText + _END_EM; 7352 7353 } 7354 7355 7356 if (oConfig.getProperty(_EMPHASIS)) { 7357 7358 sEmphasisStartTag = _START_EM; 7359 sEmphasisEndTag = _END_EM; 7360 7361 } 7362 7363 7364 if (oConfig.getProperty(_STRONG_EMPHASIS)) { 7365 7366 sEmphasisStartTag = _START_STRONG; 7367 sEmphasisEndTag = _END_STRONG; 7368 7369 } 7370 7371 7372 oAnchor.innerHTML = (sEmphasisStartTag + sText + sEmphasisEndTag + sHelpTextHTML); 7373 7374 } 7375 7376 }, 7377 7378 7379 /** 7380 * @method configHelpText 7381 * @description Event handler for when the "helptext" configuration property 7382 * of the menu item changes. 7383 * @param {String} p_sType String representing the name of the event that 7384 * was fired. 7385 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7386 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7387 * that fired the event. 7388 */ 7389 configHelpText: function (p_sType, p_aArgs, p_oItem) { 7390 7391 this.cfg.refireEvent(_TEXT); 7392 7393 }, 7394 7395 7396 /** 7397 * @method configURL 7398 * @description Event handler for when the "url" configuration property of 7399 * the menu item changes. 7400 * @param {String} p_sType String representing the name of the event that 7401 * was fired. 7402 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7403 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7404 * that fired the event. 7405 */ 7406 configURL: function (p_sType, p_aArgs, p_oItem) { 7407 7408 var sURL = p_aArgs[0]; 7409 7410 if (!sURL) { 7411 7412 sURL = _HASH; 7413 7414 } 7415 7416 var oAnchor = this._oAnchor; 7417 7418 if (UA.opera) { 7419 7420 oAnchor.removeAttribute(_HREF); 7421 7422 } 7423 7424 oAnchor.setAttribute(_HREF, sURL); 7425 7426 }, 7427 7428 7429 /** 7430 * @method configTarget 7431 * @description Event handler for when the "target" configuration property 7432 * of the menu item changes. 7433 * @param {String} p_sType String representing the name of the event that 7434 * was fired. 7435 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7436 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7437 * that fired the event. 7438 */ 7439 configTarget: function (p_sType, p_aArgs, p_oItem) { 7440 7441 var sTarget = p_aArgs[0], 7442 oAnchor = this._oAnchor; 7443 7444 if (sTarget && sTarget.length > 0) { 7445 7446 oAnchor.setAttribute(_TARGET, sTarget); 7447 7448 } 7449 else { 7450 7451 oAnchor.removeAttribute(_TARGET); 7452 7453 } 7454 7455 }, 7456 7457 7458 /** 7459 * @method configEmphasis 7460 * @description Event handler for when the "emphasis" configuration property 7461 * of the menu item changes. 7462 * @param {String} p_sType String representing the name of the event that 7463 * was fired. 7464 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7465 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7466 * that fired the event. 7467 */ 7468 configEmphasis: function (p_sType, p_aArgs, p_oItem) { 7469 7470 var bEmphasis = p_aArgs[0], 7471 oConfig = this.cfg; 7472 7473 7474 if (bEmphasis && oConfig.getProperty(_STRONG_EMPHASIS)) { 7475 7476 oConfig.setProperty(_STRONG_EMPHASIS, false); 7477 7478 } 7479 7480 7481 oConfig.refireEvent(_TEXT); 7482 7483 }, 7484 7485 7486 /** 7487 * @method configStrongEmphasis 7488 * @description Event handler for when the "strongemphasis" configuration 7489 * property of the menu item changes. 7490 * @param {String} p_sType String representing the name of the event that 7491 * was fired. 7492 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7493 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7494 * that fired the event. 7495 */ 7496 configStrongEmphasis: function (p_sType, p_aArgs, p_oItem) { 7497 7498 var bStrongEmphasis = p_aArgs[0], 7499 oConfig = this.cfg; 7500 7501 7502 if (bStrongEmphasis && oConfig.getProperty(_EMPHASIS)) { 7503 7504 oConfig.setProperty(_EMPHASIS, false); 7505 7506 } 7507 7508 oConfig.refireEvent(_TEXT); 7509 7510 }, 7511 7512 7513 /** 7514 * @method configChecked 7515 * @description Event handler for when the "checked" configuration property 7516 * of the menu item changes. 7517 * @param {String} p_sType String representing the name of the event that 7518 * was fired. 7519 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7520 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7521 * that fired the event. 7522 */ 7523 configChecked: function (p_sType, p_aArgs, p_oItem) { 7524 7525 var bChecked = p_aArgs[0], 7526 oConfig = this.cfg; 7527 7528 7529 if (bChecked) { 7530 7531 addClassNameForState.call(this, _CHECKED); 7532 7533 } 7534 else { 7535 7536 removeClassNameForState.call(this, _CHECKED); 7537 } 7538 7539 7540 oConfig.refireEvent(_TEXT); 7541 7542 7543 if (oConfig.getProperty(_DISABLED)) { 7544 7545 oConfig.refireEvent(_DISABLED); 7546 7547 } 7548 7549 7550 if (oConfig.getProperty(_SELECTED)) { 7551 7552 oConfig.refireEvent(_SELECTED); 7553 7554 } 7555 7556 }, 7557 7558 7559 7560 /** 7561 * @method configDisabled 7562 * @description Event handler for when the "disabled" configuration property 7563 * of the menu item changes. 7564 * @param {String} p_sType String representing the name of the event that 7565 * was fired. 7566 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7567 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7568 * that fired the event. 7569 */ 7570 configDisabled: function (p_sType, p_aArgs, p_oItem) { 7571 7572 var bDisabled = p_aArgs[0], 7573 oConfig = this.cfg, 7574 oSubmenu = oConfig.getProperty(_SUBMENU), 7575 bChecked = oConfig.getProperty(_CHECKED); 7576 7577 7578 if (bDisabled) { 7579 7580 if (oConfig.getProperty(_SELECTED)) { 7581 7582 oConfig.setProperty(_SELECTED, false); 7583 7584 } 7585 7586 7587 addClassNameForState.call(this, _DISABLED); 7588 7589 7590 if (oSubmenu) { 7591 7592 addClassNameForState.call(this, _HAS_SUBMENU_DISABLED); 7593 7594 } 7595 7596 7597 if (bChecked) { 7598 7599 addClassNameForState.call(this, _CHECKED_DISABLED); 7600 7601 } 7602 7603 } 7604 else { 7605 7606 removeClassNameForState.call(this, _DISABLED); 7607 7608 7609 if (oSubmenu) { 7610 7611 removeClassNameForState.call(this, _HAS_SUBMENU_DISABLED); 7612 7613 } 7614 7615 7616 if (bChecked) { 7617 7618 removeClassNameForState.call(this, _CHECKED_DISABLED); 7619 7620 } 7621 7622 } 7623 7624 }, 7625 7626 7627 /** 7628 * @method configSelected 7629 * @description Event handler for when the "selected" configuration property 7630 * of the menu item changes. 7631 * @param {String} p_sType String representing the name of the event that 7632 * was fired. 7633 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7634 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7635 * that fired the event. 7636 */ 7637 configSelected: function (p_sType, p_aArgs, p_oItem) { 7638 7639 var oConfig = this.cfg, 7640 oAnchor = this._oAnchor, 7641 7642 bSelected = p_aArgs[0], 7643 bChecked = oConfig.getProperty(_CHECKED), 7644 oSubmenu = oConfig.getProperty(_SUBMENU); 7645 7646 7647 if (UA.opera) { 7648 7649 oAnchor.blur(); 7650 7651 } 7652 7653 7654 if (bSelected && !oConfig.getProperty(_DISABLED)) { 7655 7656 addClassNameForState.call(this, _SELECTED); 7657 7658 7659 if (oSubmenu) { 7660 7661 addClassNameForState.call(this, _HAS_SUBMENU_SELECTED); 7662 7663 } 7664 7665 7666 if (bChecked) { 7667 7668 addClassNameForState.call(this, _CHECKED_SELECTED); 7669 7670 } 7671 7672 } 7673 else { 7674 7675 removeClassNameForState.call(this, _SELECTED); 7676 7677 7678 if (oSubmenu) { 7679 7680 removeClassNameForState.call(this, _HAS_SUBMENU_SELECTED); 7681 7682 } 7683 7684 7685 if (bChecked) { 7686 7687 removeClassNameForState.call(this, _CHECKED_SELECTED); 7688 7689 } 7690 7691 } 7692 7693 7694 if (this.hasFocus() && UA.opera) { 7695 7696 oAnchor.focus(); 7697 7698 } 7699 7700 }, 7701 7702 7703 /** 7704 * @method _onSubmenuBeforeHide 7705 * @description "beforehide" Custom Event handler for a submenu. 7706 * @private 7707 * @param {String} p_sType String representing the name of the event that 7708 * was fired. 7709 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7710 */ 7711 _onSubmenuBeforeHide: function (p_sType, p_aArgs) { 7712 7713 var oItem = this.parent, 7714 oMenu; 7715 7716 function onHide() { 7717 7718 oItem._oAnchor.blur(); 7719 oMenu.beforeHideEvent.unsubscribe(onHide); 7720 7721 } 7722 7723 7724 if (oItem.hasFocus()) { 7725 7726 oMenu = oItem.parent; 7727 7728 oMenu.beforeHideEvent.subscribe(onHide); 7729 7730 } 7731 7732 }, 7733 7734 7735 /** 7736 * @method configSubmenu 7737 * @description Event handler for when the "submenu" configuration property 7738 * of the menu item changes. 7739 * @param {String} p_sType String representing the name of the event that 7740 * was fired. 7741 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7742 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7743 * that fired the event. 7744 */ 7745 configSubmenu: function (p_sType, p_aArgs, p_oItem) { 7746 7747 var oSubmenu = p_aArgs[0], 7748 oConfig = this.cfg, 7749 bLazyLoad = this.parent && this.parent.lazyLoad, 7750 oMenu, 7751 sSubmenuId, 7752 oSubmenuConfig; 7753 7754 7755 if (oSubmenu) { 7756 7757 if (oSubmenu instanceof Menu) { 7758 7759 oMenu = oSubmenu; 7760 oMenu.parent = this; 7761 oMenu.lazyLoad = bLazyLoad; 7762 7763 } 7764 else if (Lang.isObject(oSubmenu) && oSubmenu.id && !oSubmenu.nodeType) { 7765 7766 sSubmenuId = oSubmenu.id; 7767 oSubmenuConfig = oSubmenu; 7768 7769 oSubmenuConfig.lazyload = bLazyLoad; 7770 oSubmenuConfig.parent = this; 7771 7772 oMenu = new this.SUBMENU_TYPE(sSubmenuId, oSubmenuConfig); 7773 7774 7775 // Set the value of the property to the Menu instance 7776 7777 oConfig.setProperty(_SUBMENU, oMenu, true); 7778 7779 } 7780 else { 7781 7782 oMenu = new this.SUBMENU_TYPE(oSubmenu, { lazyload: bLazyLoad, parent: this }); 7783 7784 7785 // Set the value of the property to the Menu instance 7786 7787 oConfig.setProperty(_SUBMENU, oMenu, true); 7788 7789 } 7790 7791 7792 if (oMenu) { 7793 7794 oMenu.cfg.setProperty(_PREVENT_CONTEXT_OVERLAP, true); 7795 7796 addClassNameForState.call(this, _HAS_SUBMENU); 7797 7798 7799 if (oConfig.getProperty(_URL) === _HASH) { 7800 7801 oConfig.setProperty(_URL, (_HASH + oMenu.id)); 7802 7803 } 7804 7805 7806 this._oSubmenu = oMenu; 7807 7808 7809 if (UA.opera) { 7810 7811 oMenu.beforeHideEvent.subscribe(this._onSubmenuBeforeHide); 7812 7813 } 7814 7815 } 7816 7817 } 7818 else { 7819 7820 removeClassNameForState.call(this, _HAS_SUBMENU); 7821 7822 if (this._oSubmenu) { 7823 7824 this._oSubmenu.destroy(); 7825 7826 } 7827 7828 } 7829 7830 7831 if (oConfig.getProperty(_DISABLED)) { 7832 7833 oConfig.refireEvent(_DISABLED); 7834 7835 } 7836 7837 7838 if (oConfig.getProperty(_SELECTED)) { 7839 7840 oConfig.refireEvent(_SELECTED); 7841 7842 } 7843 7844 }, 7845 7846 7847 /** 7848 * @method configOnClick 7849 * @description Event handler for when the "onclick" configuration property 7850 * of the menu item changes. 7851 * @param {String} p_sType String representing the name of the event that 7852 * was fired. 7853 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7854 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7855 * that fired the event. 7856 */ 7857 configOnClick: function (p_sType, p_aArgs, p_oItem) { 7858 7859 var oObject = p_aArgs[0]; 7860 7861 /* 7862 Remove any existing listeners if a "click" event handler has 7863 already been specified. 7864 */ 7865 7866 if (this._oOnclickAttributeValue && (this._oOnclickAttributeValue != oObject)) { 7867 7868 this.clickEvent.unsubscribe(this._oOnclickAttributeValue.fn, 7869 this._oOnclickAttributeValue.obj); 7870 7871 this._oOnclickAttributeValue = null; 7872 7873 } 7874 7875 7876 if (!this._oOnclickAttributeValue && Lang.isObject(oObject) && 7877 Lang.isFunction(oObject.fn)) { 7878 7879 this.clickEvent.subscribe(oObject.fn, 7880 ((_OBJ in oObject) ? oObject.obj : this), 7881 ((_SCOPE in oObject) ? oObject.scope : null) ); 7882 7883 this._oOnclickAttributeValue = oObject; 7884 7885 } 7886 7887 }, 7888 7889 7890 /** 7891 * @method configClassName 7892 * @description Event handler for when the "classname" configuration 7893 * property of a menu item changes. 7894 * @param {String} p_sType String representing the name of the event that 7895 * was fired. 7896 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 7897 * @param {YAHOO.widget.MenuItem} p_oItem Object representing the menu item 7898 * that fired the event. 7899 */ 7900 configClassName: function (p_sType, p_aArgs, p_oItem) { 7901 7902 var sClassName = p_aArgs[0]; 7903 7904 if (this._sClassName) { 7905 7906 Dom.removeClass(this.element, this._sClassName); 7907 7908 } 7909 7910 Dom.addClass(this.element, sClassName); 7911 this._sClassName = sClassName; 7912 7913 }, 7914 7915 7916 /** 7917 * @method _dispatchClickEvent 7918 * @description Dispatches a DOM "click" event to the anchor element of a 7919 * MenuItem instance. 7920 * @private 7921 */ 7922 _dispatchClickEvent: function () { 7923 7924 var oMenuItem = this, 7925 oAnchor; 7926 7927 if (!oMenuItem.cfg.getProperty(_DISABLED)) { 7928 oAnchor = Dom.getFirstChild(oMenuItem.element); 7929 7930 // Dispatch a "click" event to the MenuItem's anchor so that its 7931 // "click" event handlers will get called in response to the user 7932 // pressing the keyboard shortcut defined by the "keylistener" 7933 // configuration property. 7934 7935 this._dispatchDOMClick(oAnchor); 7936 } 7937 }, 7938 7939 /** 7940 * Utility method to dispatch a DOM click event on the HTMLElement passed in 7941 * 7942 * @method _dispatchDOMClick 7943 * @protected 7944 * @param {HTMLElement} el 7945 */ 7946 _dispatchDOMClick : function(el) { 7947 var oEvent; 7948 7949 // Choose the standards path for IE9 7950 if (UA.ie && UA.ie < 9) { 7951 el.fireEvent(_ONCLICK); 7952 } else { 7953 if ((UA.gecko && UA.gecko >= 1.9) || UA.opera || UA.webkit) { 7954 oEvent = document.createEvent("HTMLEvents"); 7955 oEvent.initEvent(_CLICK, true, true); 7956 } else { 7957 oEvent = document.createEvent("MouseEvents"); 7958 oEvent.initMouseEvent(_CLICK, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null); 7959 } 7960 el.dispatchEvent(oEvent); 7961 } 7962 }, 7963 7964 /** 7965 * @method _createKeyListener 7966 * @description "show" event handler for a Menu instance - responsible for 7967 * setting up the KeyListener instance for a MenuItem. 7968 * @private 7969 * @param {String} type String representing the name of the event that 7970 * was fired. 7971 * @param {Array} args Array of arguments sent when the event was fired. 7972 * @param {Array} keyData Array of arguments sent when the event was fired. 7973 */ 7974 _createKeyListener: function (type, args, keyData) { 7975 7976 var oMenuItem = this, 7977 oMenu = oMenuItem.parent; 7978 7979 var oKeyListener = new YAHOO.util.KeyListener( 7980 oMenu.element.ownerDocument, 7981 keyData, 7982 { 7983 fn: oMenuItem._dispatchClickEvent, 7984 scope: oMenuItem, 7985 correctScope: true }); 7986 7987 7988 if (oMenu.cfg.getProperty(_VISIBLE)) { 7989 oKeyListener.enable(); 7990 } 7991 7992 7993 oMenu.subscribe(_SHOW, oKeyListener.enable, null, oKeyListener); 7994 oMenu.subscribe(_HIDE, oKeyListener.disable, null, oKeyListener); 7995 7996 oMenuItem._keyListener = oKeyListener; 7997 7998 oMenu.unsubscribe(_SHOW, oMenuItem._createKeyListener, keyData); 7999 8000 }, 8001 8002 8003 /** 8004 * @method configKeyListener 8005 * @description Event handler for when the "keylistener" configuration 8006 * property of a menu item changes. 8007 * @param {String} p_sType String representing the name of the event that 8008 * was fired. 8009 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 8010 */ 8011 configKeyListener: function (p_sType, p_aArgs) { 8012 8013 var oKeyData = p_aArgs[0], 8014 oMenuItem = this, 8015 oMenu = oMenuItem.parent; 8016 8017 if (oMenuItem._keyData) { 8018 8019 // Unsubscribe from the "show" event in case the keylistener 8020 // config was changed before the Menu was ever made visible. 8021 8022 oMenu.unsubscribe(_SHOW, 8023 oMenuItem._createKeyListener, oMenuItem._keyData); 8024 8025 oMenuItem._keyData = null; 8026 8027 } 8028 8029 8030 // Tear down for the previous value of the "keylistener" property 8031 8032 if (oMenuItem._keyListener) { 8033 8034 oMenu.unsubscribe(_SHOW, oMenuItem._keyListener.enable); 8035 oMenu.unsubscribe(_HIDE, oMenuItem._keyListener.disable); 8036 8037 oMenuItem._keyListener.disable(); 8038 oMenuItem._keyListener = null; 8039 8040 } 8041 8042 8043 if (oKeyData) { 8044 8045 oMenuItem._keyData = oKeyData; 8046 8047 // Defer the creation of the KeyListener instance until the 8048 // parent Menu is visible. This is necessary since the 8049 // KeyListener instance needs to be bound to the document the 8050 // Menu has been rendered into. Deferring creation of the 8051 // KeyListener instance also improves performance. 8052 8053 oMenu.subscribe(_SHOW, oMenuItem._createKeyListener, 8054 oKeyData, oMenuItem); 8055 } 8056 8057 }, 8058 8059 8060 // Public methods 8061 8062 8063 /** 8064 * @method initDefaultConfig 8065 * @description Initializes an item's configurable properties. 8066 */ 8067 initDefaultConfig : function () { 8068 8069 var oConfig = this.cfg; 8070 8071 8072 // Define the configuration attributes 8073 8074 /** 8075 * @config text 8076 * @description String or markup specifying the text label for the menu item. 8077 * When building a menu from existing HTML the value of this property 8078 * will be interpreted from the menu's markup. The text is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 8079 * @default "" 8080 * @type HTML 8081 */ 8082 oConfig.addProperty( 8083 TEXT_CONFIG.key, 8084 { 8085 handler: this.configText, 8086 value: TEXT_CONFIG.value, 8087 validator: TEXT_CONFIG.validator, 8088 suppressEvent: TEXT_CONFIG.suppressEvent 8089 } 8090 ); 8091 8092 8093 /** 8094 * @config helptext 8095 * @description String or markup specifying additional instructional text to 8096 * accompany the text for the menu item. The helptext is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 8097 * @deprecated Use "text" configuration property to add help text markup. 8098 * For example: <code>oMenuItem.cfg.setProperty("text", "Copy <em 8099 * class=\"helptext\">Ctrl + C</em>");</code> 8100 * @default null 8101 * @type HTML|<a href="http://www.w3.org/TR/ 8102 * 2000/WD-DOM-Level-1-20000929/level-one-html.html#ID-58190037"> 8103 * HTMLElement</a> 8104 */ 8105 oConfig.addProperty( 8106 HELP_TEXT_CONFIG.key, 8107 { 8108 handler: this.configHelpText, 8109 supercedes: HELP_TEXT_CONFIG.supercedes, 8110 suppressEvent: HELP_TEXT_CONFIG.suppressEvent 8111 } 8112 ); 8113 8114 8115 /** 8116 * @config url 8117 * @description String specifying the URL for the menu item's anchor's 8118 * "href" attribute. When building a menu from existing HTML the value 8119 * of this property will be interpreted from the menu's markup. Markup for the menu item content. The url is inserted into the DOM as an attribute value, and should be escaped by the implementor if coming from an external source. 8120 * @default "#" 8121 * @type String 8122 */ 8123 oConfig.addProperty( 8124 URL_CONFIG.key, 8125 { 8126 handler: this.configURL, 8127 value: URL_CONFIG.value, 8128 suppressEvent: URL_CONFIG.suppressEvent 8129 } 8130 ); 8131 8132 8133 /** 8134 * @config target 8135 * @description String specifying the value for the "target" attribute 8136 * of the menu item's anchor element. <strong>Specifying a target will 8137 * require the user to click directly on the menu item's anchor node in 8138 * order to cause the browser to navigate to the specified URL.</strong> 8139 * When building a menu from existing HTML the value of this property 8140 * will be interpreted from the menu's markup. The target is inserted into the DOM as an attribute value, and should be escaped by the implementor if coming from an external source. 8141 * @default null 8142 * @type String 8143 */ 8144 oConfig.addProperty( 8145 TARGET_CONFIG.key, 8146 { 8147 handler: this.configTarget, 8148 suppressEvent: TARGET_CONFIG.suppressEvent 8149 } 8150 ); 8151 8152 8153 /** 8154 * @config emphasis 8155 * @description Boolean indicating if the text of the menu item will be 8156 * rendered with emphasis. 8157 * @deprecated Use the "text" configuration property to add emphasis. 8158 * For example: <code>oMenuItem.cfg.setProperty("text", "<em>Some 8159 * Text</em>");</code> 8160 * @default false 8161 * @type Boolean 8162 */ 8163 oConfig.addProperty( 8164 EMPHASIS_CONFIG.key, 8165 { 8166 handler: this.configEmphasis, 8167 value: EMPHASIS_CONFIG.value, 8168 validator: EMPHASIS_CONFIG.validator, 8169 suppressEvent: EMPHASIS_CONFIG.suppressEvent, 8170 supercedes: EMPHASIS_CONFIG.supercedes 8171 } 8172 ); 8173 8174 8175 /** 8176 * @config strongemphasis 8177 * @description Boolean indicating if the text of the menu item will be 8178 * rendered with strong emphasis. 8179 * @deprecated Use the "text" configuration property to add strong emphasis. 8180 * For example: <code>oMenuItem.cfg.setProperty("text", "<strong> 8181 * Some Text</strong>");</code> 8182 * @default false 8183 * @type Boolean 8184 */ 8185 oConfig.addProperty( 8186 STRONG_EMPHASIS_CONFIG.key, 8187 { 8188 handler: this.configStrongEmphasis, 8189 value: STRONG_EMPHASIS_CONFIG.value, 8190 validator: STRONG_EMPHASIS_CONFIG.validator, 8191 suppressEvent: STRONG_EMPHASIS_CONFIG.suppressEvent, 8192 supercedes: STRONG_EMPHASIS_CONFIG.supercedes 8193 } 8194 ); 8195 8196 8197 /** 8198 * @config checked 8199 * @description Boolean indicating if the menu item should be rendered 8200 * with a checkmark. 8201 * @default false 8202 * @type Boolean 8203 */ 8204 oConfig.addProperty( 8205 CHECKED_CONFIG.key, 8206 { 8207 handler: this.configChecked, 8208 value: CHECKED_CONFIG.value, 8209 validator: CHECKED_CONFIG.validator, 8210 suppressEvent: CHECKED_CONFIG.suppressEvent, 8211 supercedes: CHECKED_CONFIG.supercedes 8212 } 8213 ); 8214 8215 8216 /** 8217 * @config disabled 8218 * @description Boolean indicating if the menu item should be disabled. 8219 * (Disabled menu items are dimmed and will not respond to user input 8220 * or fire events.) 8221 * @default false 8222 * @type Boolean 8223 */ 8224 oConfig.addProperty( 8225 DISABLED_CONFIG.key, 8226 { 8227 handler: this.configDisabled, 8228 value: DISABLED_CONFIG.value, 8229 validator: DISABLED_CONFIG.validator, 8230 suppressEvent: DISABLED_CONFIG.suppressEvent 8231 } 8232 ); 8233 8234 8235 /** 8236 * @config selected 8237 * @description Boolean indicating if the menu item should 8238 * be highlighted. 8239 * @default false 8240 * @type Boolean 8241 */ 8242 oConfig.addProperty( 8243 SELECTED_CONFIG.key, 8244 { 8245 handler: this.configSelected, 8246 value: SELECTED_CONFIG.value, 8247 validator: SELECTED_CONFIG.validator, 8248 suppressEvent: SELECTED_CONFIG.suppressEvent 8249 } 8250 ); 8251 8252 8253 /** 8254 * @config submenu 8255 * @description Object specifying the submenu to be appended to the 8256 * menu item. The value can be one of the following: <ul><li>Object 8257 * specifying a Menu instance.</li><li>Object literal specifying the 8258 * menu to be created. Format: <code>{ id: [menu id], itemdata: 8259 * [<a href="YAHOO.widget.Menu.html#itemData">array of values for 8260 * items</a>] }</code>.</li><li>String specifying the id attribute 8261 * of the <code><div></code> element of the menu.</li><li> 8262 * Object specifying the <code><div></code> element of the 8263 * menu.</li></ul> 8264 * @default null 8265 * @type Menu|String|Object|<a href="http://www.w3.org/TR/2000/ 8266 * WD-DOM-Level-1-20000929/level-one-html.html#ID-58190037"> 8267 * HTMLElement</a> 8268 */ 8269 oConfig.addProperty( 8270 SUBMENU_CONFIG.key, 8271 { 8272 handler: this.configSubmenu, 8273 supercedes: SUBMENU_CONFIG.supercedes, 8274 suppressEvent: SUBMENU_CONFIG.suppressEvent 8275 } 8276 ); 8277 8278 8279 /** 8280 * @config onclick 8281 * @description Object literal representing the code to be executed when 8282 * the item is clicked. Format:<br> <code> {<br> 8283 * <strong>fn:</strong> Function, // The handler to call when 8284 * the event fires.<br> <strong>obj:</strong> Object, // An 8285 * object to pass back to the handler.<br> <strong>scope:</strong> 8286 * Object // The object to use for the scope of the handler. 8287 * <br> } </code> 8288 * @type Object 8289 * @default null 8290 */ 8291 oConfig.addProperty( 8292 ONCLICK_CONFIG.key, 8293 { 8294 handler: this.configOnClick, 8295 suppressEvent: ONCLICK_CONFIG.suppressEvent 8296 } 8297 ); 8298 8299 8300 /** 8301 * @config classname 8302 * @description CSS class to be applied to the menu item's root 8303 * <code><li></code> element. The specified class(es) are 8304 * appended in addition to the default class as specified by the menu 8305 * item's CSS_CLASS_NAME constant. 8306 * @default null 8307 * @type String 8308 */ 8309 oConfig.addProperty( 8310 CLASS_NAME_CONFIG.key, 8311 { 8312 handler: this.configClassName, 8313 value: CLASS_NAME_CONFIG.value, 8314 validator: CLASS_NAME_CONFIG.validator, 8315 suppressEvent: CLASS_NAME_CONFIG.suppressEvent 8316 } 8317 ); 8318 8319 8320 /** 8321 * @config keylistener 8322 * @description Object literal representing the key(s) that can be used 8323 * to trigger the MenuItem's "click" event. Possible attributes are 8324 * shift (boolean), alt (boolean), ctrl (boolean) and keys (either an int 8325 * or an array of ints representing keycodes). 8326 * @default null 8327 * @type Object 8328 */ 8329 oConfig.addProperty( 8330 KEY_LISTENER_CONFIG.key, 8331 { 8332 handler: this.configKeyListener, 8333 value: KEY_LISTENER_CONFIG.value, 8334 suppressEvent: KEY_LISTENER_CONFIG.suppressEvent 8335 } 8336 ); 8337 8338 }, 8339 8340 /** 8341 * @method getNextSibling 8342 * @description Finds the menu item's next sibling. 8343 * @return YAHOO.widget.MenuItem 8344 */ 8345 getNextSibling: function () { 8346 8347 var isUL = function (el) { 8348 return (el.nodeName.toLowerCase() === "ul"); 8349 }, 8350 8351 menuitemEl = this.element, 8352 next = Dom.getNextSibling(menuitemEl), 8353 parent, 8354 sibling, 8355 list; 8356 8357 if (!next) { 8358 8359 parent = menuitemEl.parentNode; 8360 sibling = Dom.getNextSiblingBy(parent, isUL); 8361 8362 if (sibling) { 8363 list = sibling; 8364 } 8365 else { 8366 list = Dom.getFirstChildBy(parent.parentNode, isUL); 8367 } 8368 8369 next = Dom.getFirstChild(list); 8370 8371 } 8372 8373 return YAHOO.widget.MenuManager.getMenuItem(next.id); 8374 8375 }, 8376 8377 /** 8378 * @method getNextEnabledSibling 8379 * @description Finds the menu item's next enabled sibling. 8380 * @return YAHOO.widget.MenuItem 8381 */ 8382 getNextEnabledSibling: function () { 8383 8384 var next = this.getNextSibling(); 8385 8386 return (next.cfg.getProperty(_DISABLED) || next.element.style.display == _NONE) ? next.getNextEnabledSibling() : next; 8387 8388 }, 8389 8390 8391 /** 8392 * @method getPreviousSibling 8393 * @description Finds the menu item's previous sibling. 8394 * @return {YAHOO.widget.MenuItem} 8395 */ 8396 getPreviousSibling: function () { 8397 8398 var isUL = function (el) { 8399 return (el.nodeName.toLowerCase() === "ul"); 8400 }, 8401 8402 menuitemEl = this.element, 8403 next = Dom.getPreviousSibling(menuitemEl), 8404 parent, 8405 sibling, 8406 list; 8407 8408 if (!next) { 8409 8410 parent = menuitemEl.parentNode; 8411 sibling = Dom.getPreviousSiblingBy(parent, isUL); 8412 8413 if (sibling) { 8414 list = sibling; 8415 } 8416 else { 8417 list = Dom.getLastChildBy(parent.parentNode, isUL); 8418 } 8419 8420 next = Dom.getLastChild(list); 8421 8422 } 8423 8424 return YAHOO.widget.MenuManager.getMenuItem(next.id); 8425 8426 }, 8427 8428 8429 /** 8430 * @method getPreviousEnabledSibling 8431 * @description Finds the menu item's previous enabled sibling. 8432 * @return {YAHOO.widget.MenuItem} 8433 */ 8434 getPreviousEnabledSibling: function () { 8435 8436 var next = this.getPreviousSibling(); 8437 8438 return (next.cfg.getProperty(_DISABLED) || next.element.style.display == _NONE) ? next.getPreviousEnabledSibling() : next; 8439 8440 }, 8441 8442 8443 /** 8444 * @method focus 8445 * @description Causes the menu item to receive the focus and fires the 8446 * focus event. 8447 */ 8448 focus: function () { 8449 8450 var oParent = this.parent, 8451 oAnchor = this._oAnchor, 8452 oActiveItem = oParent.activeItem; 8453 8454 8455 function setFocus() { 8456 8457 try { 8458 8459 if (!(UA.ie && !document.hasFocus())) { 8460 8461 if (oActiveItem) { 8462 8463 oActiveItem.blurEvent.fire(); 8464 8465 } 8466 8467 oAnchor.focus(); 8468 8469 this.focusEvent.fire(); 8470 8471 } 8472 8473 } 8474 catch(e) { 8475 8476 } 8477 8478 } 8479 8480 8481 if (!this.cfg.getProperty(_DISABLED) && oParent && oParent.cfg.getProperty(_VISIBLE) && 8482 this.element.style.display != _NONE) { 8483 8484 8485 /* 8486 Setting focus via a timer fixes a race condition in Firefox, IE 8487 and Opera where the browser viewport jumps as it trys to 8488 position and focus the menu. 8489 */ 8490 8491 Lang.later(0, this, setFocus); 8492 8493 } 8494 8495 }, 8496 8497 8498 /** 8499 * @method blur 8500 * @description Causes the menu item to lose focus and fires the 8501 * blur event. 8502 */ 8503 blur: function () { 8504 8505 var oParent = this.parent; 8506 8507 if (!this.cfg.getProperty(_DISABLED) && oParent && oParent.cfg.getProperty(_VISIBLE)) { 8508 8509 Lang.later(0, this, function () { 8510 8511 try { 8512 8513 this._oAnchor.blur(); 8514 this.blurEvent.fire(); 8515 8516 } 8517 catch (e) { 8518 8519 } 8520 8521 }, 0); 8522 8523 } 8524 8525 }, 8526 8527 8528 /** 8529 * @method hasFocus 8530 * @description Returns a boolean indicating whether or not the menu item 8531 * has focus. 8532 * @return {Boolean} 8533 */ 8534 hasFocus: function () { 8535 8536 return (YAHOO.widget.MenuManager.getFocusedMenuItem() == this); 8537 8538 }, 8539 8540 8541 /** 8542 * @method destroy 8543 * @description Removes the menu item's <code><li></code> element 8544 * from its parent <code><ul></code> element. 8545 */ 8546 destroy: function () { 8547 8548 var oEl = this.element, 8549 oSubmenu, 8550 oParentNode, 8551 aEventData, 8552 i; 8553 8554 8555 if (oEl) { 8556 8557 8558 // If the item has a submenu, destroy it first 8559 8560 oSubmenu = this.cfg.getProperty(_SUBMENU); 8561 8562 if (oSubmenu) { 8563 8564 oSubmenu.destroy(); 8565 8566 } 8567 8568 8569 // Remove the element from the parent node 8570 8571 oParentNode = oEl.parentNode; 8572 8573 if (oParentNode) { 8574 8575 oParentNode.removeChild(oEl); 8576 8577 this.destroyEvent.fire(); 8578 8579 } 8580 8581 8582 // Remove CustomEvent listeners 8583 8584 i = EVENT_TYPES.length - 1; 8585 8586 do { 8587 8588 aEventData = EVENT_TYPES[i]; 8589 8590 this[aEventData[0]].unsubscribeAll(); 8591 8592 } 8593 while (i--); 8594 8595 8596 this.cfg.configChangedEvent.unsubscribeAll(); 8597 8598 } 8599 8600 }, 8601 8602 8603 /** 8604 * @method toString 8605 * @description Returns a string representing the menu item. 8606 * @return {String} 8607 */ 8608 toString: function () { 8609 8610 var sReturnVal = _MENUITEM, 8611 sId = this.id; 8612 8613 if (sId) { 8614 8615 sReturnVal += (_SPACE + sId); 8616 8617 } 8618 8619 return sReturnVal; 8620 8621 } 8622 8623 }; 8624 8625 Lang.augmentProto(MenuItem, YAHOO.util.EventProvider); 8626 8627 })(); 8628 (function () { 8629 8630 var _XY = "xy", 8631 _MOUSEDOWN = "mousedown", 8632 _CONTEXTMENU = "ContextMenu", 8633 _SPACE = " "; 8634 8635 /** 8636 * Creates a list of options or commands which are made visible in response to 8637 * an HTML element's "contextmenu" event ("mousedown" for Opera). 8638 * 8639 * @param {String} p_oElement String specifying the id attribute of the 8640 * <code><div></code> element of the context menu. 8641 * @param {String} p_oElement String specifying the id attribute of the 8642 * <code><select></code> element to be used as the data source for the 8643 * context menu. 8644 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one- 8645 * html.html#ID-22445964">HTMLDivElement</a>} p_oElement Object specifying the 8646 * <code><div></code> element of the context menu. 8647 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one- 8648 * html.html#ID-94282980">HTMLSelectElement</a>} p_oElement Object specifying 8649 * the <code><select></code> element to be used as the data source for 8650 * the context menu. 8651 * @param {Object} p_oConfig Optional. Object literal specifying the 8652 * configuration for the context menu. See configuration class documentation 8653 * for more details. 8654 * @class ContextMenu 8655 * @constructor 8656 * @extends YAHOO.widget.Menu 8657 * @namespace YAHOO.widget 8658 */ 8659 YAHOO.widget.ContextMenu = function(p_oElement, p_oConfig) { 8660 YAHOO.widget.ContextMenu.superclass.constructor.call(this, p_oElement, p_oConfig); 8661 }; 8662 8663 8664 var Event = YAHOO.util.Event, 8665 UA = YAHOO.env.ua, 8666 ContextMenu = YAHOO.widget.ContextMenu, 8667 8668 8669 8670 /** 8671 * Constant representing the name of the ContextMenu's events 8672 * @property EVENT_TYPES 8673 * @private 8674 * @final 8675 * @type Object 8676 */ 8677 EVENT_TYPES = { 8678 8679 "TRIGGER_CONTEXT_MENU": "triggerContextMenu", 8680 "CONTEXT_MENU": (UA.opera ? _MOUSEDOWN : "contextmenu"), 8681 "CLICK": "click" 8682 8683 }, 8684 8685 8686 /** 8687 * Constant representing the ContextMenu's configuration properties 8688 * @property DEFAULT_CONFIG 8689 * @private 8690 * @final 8691 * @type Object 8692 */ 8693 TRIGGER_CONFIG = { 8694 key: "trigger", 8695 suppressEvent: true 8696 }; 8697 8698 8699 /** 8700 * @method position 8701 * @description "beforeShow" event handler used to position the contextmenu. 8702 * @private 8703 * @param {String} p_sType String representing the name of the event that 8704 * was fired. 8705 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 8706 * @param {Array} p_aPos Array representing the xy position for the context menu. 8707 */ 8708 function position(p_sType, p_aArgs, p_aPos) { 8709 this.cfg.setProperty(_XY, p_aPos); 8710 this.beforeShowEvent.unsubscribe(position, p_aPos); 8711 } 8712 8713 8714 YAHOO.lang.extend(ContextMenu, YAHOO.widget.Menu, { 8715 8716 8717 8718 // Private properties 8719 8720 8721 /** 8722 * @property _oTrigger 8723 * @description Object reference to the current value of the "trigger" 8724 * configuration property. 8725 * @default null 8726 * @private 8727 * @type String|<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/leve 8728 * l-one-html.html#ID-58190037">HTMLElement</a>|Array 8729 */ 8730 _oTrigger: null, 8731 8732 8733 /** 8734 * @property _bCancelled 8735 * @description Boolean indicating if the display of the context menu should 8736 * be cancelled. 8737 * @default false 8738 * @private 8739 * @type Boolean 8740 */ 8741 _bCancelled: false, 8742 8743 8744 8745 // Public properties 8746 8747 8748 /** 8749 * @property contextEventTarget 8750 * @description Object reference for the HTML element that was the target of the 8751 * "contextmenu" DOM event ("mousedown" for Opera) that triggered the display of 8752 * the context menu. 8753 * @default null 8754 * @type <a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one- 8755 * html.html#ID-58190037">HTMLElement</a> 8756 */ 8757 contextEventTarget: null, 8758 8759 8760 8761 // Events 8762 8763 8764 /** 8765 * @event triggerContextMenuEvent 8766 * @param type {String} The name of the event, "triggerContextMenu" 8767 * @param args {Array} The array of event arguments. For this event, the underlying 8768 * DOM event is the only argument, available from args[0]. 8769 * @description Custom Event wrapper for the "contextmenu" DOM event 8770 * ("mousedown" for Opera) fired by the element(s) that trigger the display of 8771 * the context menu. 8772 */ 8773 triggerContextMenuEvent: null, 8774 8775 8776 8777 /** 8778 * @method init 8779 * @description The ContextMenu class's initialization method. This method is 8780 * automatically called by the constructor, and sets up all DOM references for 8781 * pre-existing markup, and creates required markup if it is not already present. 8782 * @param {String} p_oElement String specifying the id attribute of the 8783 * <code><div></code> element of the context menu. 8784 * @param {String} p_oElement String specifying the id attribute of the 8785 * <code><select></code> element to be used as the data source for 8786 * the context menu. 8787 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one- 8788 * html.html#ID-22445964">HTMLDivElement</a>} p_oElement Object specifying the 8789 * <code><div></code> element of the context menu. 8790 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one- 8791 * html.html#ID-94282980">HTMLSelectElement</a>} p_oElement Object specifying 8792 * the <code><select></code> element to be used as the data source for 8793 * the context menu. 8794 * @param {Object} p_oConfig Optional. Object literal specifying the 8795 * configuration for the context menu. See configuration class documentation 8796 * for more details. 8797 */ 8798 init: function(p_oElement, p_oConfig) { 8799 8800 8801 // Call the init of the superclass (YAHOO.widget.Menu) 8802 8803 ContextMenu.superclass.init.call(this, p_oElement); 8804 8805 this.beforeInitEvent.fire(ContextMenu); 8806 8807 if (p_oConfig) { 8808 this.cfg.applyConfig(p_oConfig, true); 8809 } 8810 8811 this.initEvent.fire(ContextMenu); 8812 }, 8813 8814 8815 /** 8816 * @method initEvents 8817 * @description Initializes the custom events for the context menu. 8818 */ 8819 initEvents: function() { 8820 ContextMenu.superclass.initEvents.call(this); 8821 8822 // Create custom events 8823 this.triggerContextMenuEvent = this.createEvent(EVENT_TYPES.TRIGGER_CONTEXT_MENU); 8824 this.triggerContextMenuEvent.signature = YAHOO.util.CustomEvent.LIST; 8825 }, 8826 8827 /** 8828 * @method cancel 8829 * @description Cancels the display of the context menu. 8830 */ 8831 cancel: function() { 8832 this._bCancelled = true; 8833 }, 8834 8835 // Private methods 8836 8837 8838 /** 8839 * @method _removeEventHandlers 8840 * @description Removes all of the DOM event handlers from the HTML element(s) 8841 * whose "context menu" event ("click" for Opera) trigger the display of 8842 * the context menu. 8843 * @private 8844 */ 8845 _removeEventHandlers: function() { 8846 8847 var oTrigger = this._oTrigger; 8848 8849 // Remove the event handlers from the trigger(s) 8850 if (oTrigger) { 8851 Event.removeListener(oTrigger, EVENT_TYPES.CONTEXT_MENU, this._onTriggerContextMenu); 8852 8853 if (UA.opera) { 8854 Event.removeListener(oTrigger, EVENT_TYPES.CLICK, this._onTriggerClick); 8855 } 8856 } 8857 8858 }, 8859 8860 // Private event handlers 8861 8862 /** 8863 * @method _onTriggerClick 8864 * @description "click" event handler for the HTML element(s) identified as the 8865 * "trigger" for the context menu. Used to cancel default behaviors in Opera. 8866 * @private 8867 * @param {Event} p_oEvent Object representing the DOM event object passed back 8868 * by the event utility (YAHOO.util.Event). 8869 * @param {YAHOO.widget.ContextMenu} p_oMenu Object representing the context 8870 * menu that is handling the event. 8871 */ 8872 _onTriggerClick: function(p_oEvent, p_oMenu) { 8873 8874 if (p_oEvent.ctrlKey) { 8875 Event.stopEvent(p_oEvent); 8876 } 8877 8878 }, 8879 8880 8881 /** 8882 * @method _onTriggerContextMenu 8883 * @description "contextmenu" event handler ("mousedown" for Opera) for the HTML 8884 * element(s) that trigger the display of the context menu. 8885 * @private 8886 * @param {Event} p_oEvent Object representing the DOM event object passed back 8887 * by the event utility (YAHOO.util.Event). 8888 * @param {YAHOO.widget.ContextMenu} p_oMenu Object representing the context 8889 * menu that is handling the event. 8890 */ 8891 _onTriggerContextMenu: function(p_oEvent, p_oMenu) { 8892 8893 var aXY; 8894 8895 if (!(p_oEvent.type == _MOUSEDOWN && !p_oEvent.ctrlKey)) { 8896 8897 this.contextEventTarget = Event.getTarget(p_oEvent); 8898 8899 this.triggerContextMenuEvent.fire(p_oEvent); 8900 8901 8902 if (!this._bCancelled) { 8903 8904 /* 8905 Prevent the browser's default context menu from appearing and 8906 stop the propagation of the "contextmenu" event so that 8907 other ContextMenu instances are not displayed. 8908 */ 8909 8910 Event.stopEvent(p_oEvent); 8911 8912 8913 // Hide any other Menu instances that might be visible 8914 8915 YAHOO.widget.MenuManager.hideVisible(); 8916 8917 8918 8919 // Position and display the context menu 8920 8921 aXY = Event.getXY(p_oEvent); 8922 8923 8924 if (!YAHOO.util.Dom.inDocument(this.element)) { 8925 8926 this.beforeShowEvent.subscribe(position, aXY); 8927 8928 } 8929 else { 8930 8931 this.cfg.setProperty(_XY, aXY); 8932 8933 } 8934 8935 8936 this.show(); 8937 8938 } 8939 8940 this._bCancelled = false; 8941 8942 } 8943 8944 }, 8945 8946 8947 8948 // Public methods 8949 8950 8951 /** 8952 * @method toString 8953 * @description Returns a string representing the context menu. 8954 * @return {String} 8955 */ 8956 toString: function() { 8957 8958 var sReturnVal = _CONTEXTMENU, 8959 sId = this.id; 8960 8961 if (sId) { 8962 8963 sReturnVal += (_SPACE + sId); 8964 8965 } 8966 8967 return sReturnVal; 8968 8969 }, 8970 8971 8972 /** 8973 * @method initDefaultConfig 8974 * @description Initializes the class's configurable properties which can be 8975 * changed using the context menu's Config object ("cfg"). 8976 */ 8977 initDefaultConfig: function() { 8978 8979 ContextMenu.superclass.initDefaultConfig.call(this); 8980 8981 /** 8982 * @config trigger 8983 * @description The HTML element(s) whose "contextmenu" event ("mousedown" 8984 * for Opera) trigger the display of the context menu. Can be a string 8985 * representing the id attribute of the HTML element, an object reference 8986 * for the HTML element, or an array of strings or HTML element references. 8987 * @default null 8988 * @type String|<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/ 8989 * level-one-html.html#ID-58190037">HTMLElement</a>|Array 8990 */ 8991 this.cfg.addProperty(TRIGGER_CONFIG.key, 8992 { 8993 handler: this.configTrigger, 8994 suppressEvent: TRIGGER_CONFIG.suppressEvent 8995 } 8996 ); 8997 8998 }, 8999 9000 9001 /** 9002 * @method destroy 9003 * @description Removes the context menu's <code><div></code> element 9004 * (and accompanying child nodes) from the document. 9005 * @param {boolean} shallowPurge If true, only the parent element's DOM event listeners are purged. If false, or not provided, all children are also purged of DOM event listeners. 9006 * NOTE: The flag is a "shallowPurge" flag, as opposed to what may be a more intuitive "purgeChildren" flag to maintain backwards compatibility with behavior prior to 2.9.0. 9007 */ 9008 destroy: function(shallowPurge) { 9009 9010 // Remove the DOM event handlers from the current trigger(s) 9011 9012 this._removeEventHandlers(); 9013 9014 9015 // Continue with the superclass implementation of this method 9016 9017 ContextMenu.superclass.destroy.call(this, shallowPurge); 9018 9019 }, 9020 9021 9022 9023 // Public event handlers for configuration properties 9024 9025 9026 /** 9027 * @method configTrigger 9028 * @description Event handler for when the value of the "trigger" configuration 9029 * property changes. 9030 * @param {String} p_sType String representing the name of the event that 9031 * was fired. 9032 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 9033 * @param {YAHOO.widget.ContextMenu} p_oMenu Object representing the context 9034 * menu that fired the event. 9035 */ 9036 configTrigger: function(p_sType, p_aArgs, p_oMenu) { 9037 9038 var oTrigger = p_aArgs[0]; 9039 9040 if (oTrigger) { 9041 9042 /* 9043 If there is a current "trigger" - remove the event handlers 9044 from that element(s) before assigning new ones 9045 */ 9046 9047 if (this._oTrigger) { 9048 9049 this._removeEventHandlers(); 9050 9051 } 9052 9053 this._oTrigger = oTrigger; 9054 9055 9056 /* 9057 Listen for the "mousedown" event in Opera b/c it does not 9058 support the "contextmenu" event 9059 */ 9060 9061 Event.on(oTrigger, EVENT_TYPES.CONTEXT_MENU, this._onTriggerContextMenu, this, true); 9062 9063 9064 /* 9065 Assign a "click" event handler to the trigger element(s) for 9066 Opera to prevent default browser behaviors. 9067 */ 9068 9069 if (UA.opera) { 9070 9071 Event.on(oTrigger, EVENT_TYPES.CLICK, this._onTriggerClick, this, true); 9072 9073 } 9074 9075 } 9076 else { 9077 9078 this._removeEventHandlers(); 9079 9080 } 9081 9082 } 9083 9084 }); // END YAHOO.lang.extend 9085 9086 }()); 9087 9088 9089 9090 /** 9091 * Creates an item for a context menu. 9092 * 9093 * @param {String} p_oObject String specifying the text of the context menu item. 9094 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9095 * one-html.html#ID-74680021">HTMLLIElement</a>} p_oObject Object specifying the 9096 * <code><li></code> element of the context menu item. 9097 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9098 * one-html.html#ID-38450247">HTMLOptGroupElement</a>} p_oObject Object 9099 * specifying the <code><optgroup></code> element of the context 9100 * menu item. 9101 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9102 * one-html.html#ID-70901257">HTMLOptionElement</a>} p_oObject Object specifying 9103 * the <code><option></code> element of the context menu item. 9104 * @param {Object} p_oConfig Optional. Object literal specifying the 9105 * configuration for the context menu item. See configuration class 9106 * documentation for more details. 9107 * @class ContextMenuItem 9108 * @constructor 9109 * @extends YAHOO.widget.MenuItem 9110 * @deprecated As of version 2.4.0 items for YAHOO.widget.ContextMenu instances 9111 * are of type YAHOO.widget.MenuItem. 9112 */ 9113 YAHOO.widget.ContextMenuItem = YAHOO.widget.MenuItem; 9114 (function () { 9115 9116 var Lang = YAHOO.lang, 9117 9118 // String constants 9119 9120 _STATIC = "static", 9121 _DYNAMIC_STATIC = "dynamic," + _STATIC, 9122 _DISABLED = "disabled", 9123 _SELECTED = "selected", 9124 _AUTO_SUBMENU_DISPLAY = "autosubmenudisplay", 9125 _SUBMENU = "submenu", 9126 _VISIBLE = "visible", 9127 _SPACE = " ", 9128 _SUBMENU_TOGGLE_REGION = "submenutoggleregion", 9129 _MENUBAR = "MenuBar"; 9130 9131 /** 9132 * Horizontal collection of items, each of which can contain a submenu. 9133 * 9134 * @param {String} p_oElement String specifying the id attribute of the 9135 * <code><div></code> element of the menu bar. 9136 * @param {String} p_oElement String specifying the id attribute of the 9137 * <code><select></code> element to be used as the data source for the 9138 * menu bar. 9139 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9140 * one-html.html#ID-22445964">HTMLDivElement</a>} p_oElement Object specifying 9141 * the <code><div></code> element of the menu bar. 9142 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9143 * one-html.html#ID-94282980">HTMLSelectElement</a>} p_oElement Object 9144 * specifying the <code><select></code> element to be used as the data 9145 * source for the menu bar. 9146 * @param {Object} p_oConfig Optional. Object literal specifying the 9147 * configuration for the menu bar. See configuration class documentation for 9148 * more details. 9149 * @class MenuBar 9150 * @constructor 9151 * @extends YAHOO.widget.Menu 9152 * @namespace YAHOO.widget 9153 */ 9154 YAHOO.widget.MenuBar = function(p_oElement, p_oConfig) { 9155 9156 YAHOO.widget.MenuBar.superclass.constructor.call(this, p_oElement, p_oConfig); 9157 9158 }; 9159 9160 9161 /** 9162 * @method checkPosition 9163 * @description Checks to make sure that the value of the "position" property 9164 * is one of the supported strings. Returns true if the position is supported. 9165 * @private 9166 * @param {Object} p_sPosition String specifying the position of the menu. 9167 * @return {Boolean} 9168 */ 9169 function checkPosition(p_sPosition) { 9170 9171 var returnVal = false; 9172 9173 if (Lang.isString(p_sPosition)) { 9174 9175 returnVal = (_DYNAMIC_STATIC.indexOf((p_sPosition.toLowerCase())) != -1); 9176 9177 } 9178 9179 return returnVal; 9180 9181 } 9182 9183 9184 var Event = YAHOO.util.Event, 9185 MenuBar = YAHOO.widget.MenuBar, 9186 9187 POSITION_CONFIG = { 9188 key: "position", 9189 value: _STATIC, 9190 validator: checkPosition, 9191 supercedes: [_VISIBLE] 9192 }, 9193 9194 SUBMENU_ALIGNMENT_CONFIG = { 9195 key: "submenualignment", 9196 value: ["tl","bl"] 9197 }, 9198 9199 AUTO_SUBMENU_DISPLAY_CONFIG = { 9200 key: _AUTO_SUBMENU_DISPLAY, 9201 value: false, 9202 validator: Lang.isBoolean, 9203 suppressEvent: true 9204 }, 9205 9206 SUBMENU_TOGGLE_REGION_CONFIG = { 9207 key: _SUBMENU_TOGGLE_REGION, 9208 value: false, 9209 validator: Lang.isBoolean 9210 }; 9211 9212 9213 9214 Lang.extend(MenuBar, YAHOO.widget.Menu, { 9215 9216 /** 9217 * @method init 9218 * @description The MenuBar class's initialization method. This method is 9219 * automatically called by the constructor, and sets up all DOM references for 9220 * pre-existing markup, and creates required markup if it is not already present. 9221 * @param {String} p_oElement String specifying the id attribute of the 9222 * <code><div></code> element of the menu bar. 9223 * @param {String} p_oElement String specifying the id attribute of the 9224 * <code><select></code> element to be used as the data source for the 9225 * menu bar. 9226 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9227 * one-html.html#ID-22445964">HTMLDivElement</a>} p_oElement Object specifying 9228 * the <code><div></code> element of the menu bar. 9229 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9230 * one-html.html#ID-94282980">HTMLSelectElement</a>} p_oElement Object 9231 * specifying the <code><select></code> element to be used as the data 9232 * source for the menu bar. 9233 * @param {Object} p_oConfig Optional. Object literal specifying the 9234 * configuration for the menu bar. See configuration class documentation for 9235 * more details. 9236 */ 9237 init: function(p_oElement, p_oConfig) { 9238 9239 if(!this.ITEM_TYPE) { 9240 9241 this.ITEM_TYPE = YAHOO.widget.MenuBarItem; 9242 9243 } 9244 9245 9246 // Call the init of the superclass (YAHOO.widget.Menu) 9247 9248 MenuBar.superclass.init.call(this, p_oElement); 9249 9250 9251 this.beforeInitEvent.fire(MenuBar); 9252 9253 9254 if(p_oConfig) { 9255 9256 this.cfg.applyConfig(p_oConfig, true); 9257 9258 } 9259 9260 this.initEvent.fire(MenuBar); 9261 9262 }, 9263 9264 9265 9266 // Constants 9267 9268 9269 /** 9270 * @property CSS_CLASS_NAME 9271 * @description String representing the CSS class(es) to be applied to the menu 9272 * bar's <code><div></code> element. 9273 * @default "yuimenubar" 9274 * @final 9275 * @type String 9276 */ 9277 CSS_CLASS_NAME: "yuimenubar", 9278 9279 9280 /** 9281 * @property SUBMENU_TOGGLE_REGION_WIDTH 9282 * @description Width (in pixels) of the area of a MenuBarItem that, when pressed, will toggle the 9283 * display of the MenuBarItem's submenu. 9284 * @default 20 9285 * @final 9286 * @type Number 9287 */ 9288 SUBMENU_TOGGLE_REGION_WIDTH: 20, 9289 9290 9291 // Protected event handlers 9292 9293 9294 /** 9295 * @method _onKeyDown 9296 * @description "keydown" Custom Event handler for the menu bar. 9297 * @private 9298 * @param {String} p_sType String representing the name of the event that 9299 * was fired. 9300 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 9301 * @param {YAHOO.widget.MenuBar} p_oMenuBar Object representing the menu bar 9302 * that fired the event. 9303 */ 9304 _onKeyDown: function(p_sType, p_aArgs, p_oMenuBar) { 9305 9306 var oEvent = p_aArgs[0], 9307 oItem = p_aArgs[1], 9308 oSubmenu, 9309 oItemCfg, 9310 oNextItem; 9311 9312 9313 if(oItem && !oItem.cfg.getProperty(_DISABLED)) { 9314 9315 oItemCfg = oItem.cfg; 9316 9317 switch(oEvent.keyCode) { 9318 9319 case 37: // Left arrow 9320 case 39: // Right arrow 9321 9322 if(oItem == this.activeItem && !oItemCfg.getProperty(_SELECTED)) { 9323 9324 oItemCfg.setProperty(_SELECTED, true); 9325 9326 } 9327 else { 9328 9329 oNextItem = (oEvent.keyCode == 37) ? 9330 oItem.getPreviousEnabledSibling() : 9331 oItem.getNextEnabledSibling(); 9332 9333 if(oNextItem) { 9334 9335 this.clearActiveItem(); 9336 9337 oNextItem.cfg.setProperty(_SELECTED, true); 9338 9339 oSubmenu = oNextItem.cfg.getProperty(_SUBMENU); 9340 9341 if(oSubmenu) { 9342 9343 oSubmenu.show(); 9344 oSubmenu.setInitialFocus(); 9345 9346 } 9347 else { 9348 oNextItem.focus(); 9349 } 9350 9351 } 9352 9353 } 9354 9355 Event.preventDefault(oEvent); 9356 9357 break; 9358 9359 case 40: // Down arrow 9360 9361 if(this.activeItem != oItem) { 9362 9363 this.clearActiveItem(); 9364 9365 oItemCfg.setProperty(_SELECTED, true); 9366 oItem.focus(); 9367 9368 } 9369 9370 oSubmenu = oItemCfg.getProperty(_SUBMENU); 9371 9372 if(oSubmenu) { 9373 9374 if(oSubmenu.cfg.getProperty(_VISIBLE)) { 9375 9376 oSubmenu.setInitialSelection(); 9377 oSubmenu.setInitialFocus(); 9378 9379 } 9380 else { 9381 9382 oSubmenu.show(); 9383 oSubmenu.setInitialFocus(); 9384 9385 } 9386 9387 } 9388 9389 Event.preventDefault(oEvent); 9390 9391 break; 9392 9393 } 9394 9395 } 9396 9397 9398 if(oEvent.keyCode == 27 && this.activeItem) { // Esc key 9399 9400 oSubmenu = this.activeItem.cfg.getProperty(_SUBMENU); 9401 9402 if(oSubmenu && oSubmenu.cfg.getProperty(_VISIBLE)) { 9403 9404 oSubmenu.hide(); 9405 this.activeItem.focus(); 9406 9407 } 9408 else { 9409 9410 this.activeItem.cfg.setProperty(_SELECTED, false); 9411 this.activeItem.blur(); 9412 9413 } 9414 9415 Event.preventDefault(oEvent); 9416 9417 } 9418 9419 }, 9420 9421 9422 /** 9423 * @method _onClick 9424 * @description "click" event handler for the menu bar. 9425 * @protected 9426 * @param {String} p_sType String representing the name of the event that 9427 * was fired. 9428 * @param {Array} p_aArgs Array of arguments sent when the event was fired. 9429 * @param {YAHOO.widget.MenuBar} p_oMenuBar Object representing the menu bar 9430 * that fired the event. 9431 */ 9432 _onClick: function(p_sType, p_aArgs, p_oMenuBar) { 9433 9434 MenuBar.superclass._onClick.call(this, p_sType, p_aArgs, p_oMenuBar); 9435 9436 var oItem = p_aArgs[1], 9437 bReturnVal = true, 9438 oItemEl, 9439 oEvent, 9440 oTarget, 9441 oActiveItem, 9442 oConfig, 9443 oSubmenu, 9444 nMenuItemX, 9445 nToggleRegion; 9446 9447 9448 var toggleSubmenuDisplay = function () { 9449 9450 if(oSubmenu.cfg.getProperty(_VISIBLE)) { 9451 9452 oSubmenu.hide(); 9453 9454 } 9455 else { 9456 9457 oSubmenu.show(); 9458 9459 } 9460 9461 }; 9462 9463 9464 if(oItem && !oItem.cfg.getProperty(_DISABLED)) { 9465 9466 oEvent = p_aArgs[0]; 9467 oTarget = Event.getTarget(oEvent); 9468 oActiveItem = this.activeItem; 9469 oConfig = this.cfg; 9470 9471 9472 // Hide any other submenus that might be visible 9473 9474 if(oActiveItem && oActiveItem != oItem) { 9475 9476 this.clearActiveItem(); 9477 9478 } 9479 9480 9481 oItem.cfg.setProperty(_SELECTED, true); 9482 9483 9484 // Show the submenu for the item 9485 9486 oSubmenu = oItem.cfg.getProperty(_SUBMENU); 9487 9488 9489 if(oSubmenu) { 9490 9491 oItemEl = oItem.element; 9492 nMenuItemX = YAHOO.util.Dom.getX(oItemEl); 9493 nToggleRegion = nMenuItemX + (oItemEl.offsetWidth - this.SUBMENU_TOGGLE_REGION_WIDTH); 9494 9495 if (oConfig.getProperty(_SUBMENU_TOGGLE_REGION)) { 9496 9497 if (Event.getPageX(oEvent) > nToggleRegion) { 9498 9499 toggleSubmenuDisplay(); 9500 9501 Event.preventDefault(oEvent); 9502 9503 /* 9504 Return false so that other click event handlers are not called when the 9505 user clicks inside the toggle region. 9506 */ 9507 bReturnVal = false; 9508 9509 } 9510 9511 } 9512 else { 9513 9514 toggleSubmenuDisplay(); 9515 9516 } 9517 9518 } 9519 9520 } 9521 9522 9523 return bReturnVal; 9524 9525 }, 9526 9527 9528 9529 // Public methods 9530 9531 /** 9532 * @method configSubmenuToggle 9533 * @description Event handler for when the "submenutoggleregion" configuration property of 9534 * a MenuBar changes. 9535 * @param {String} p_sType The name of the event that was fired. 9536 * @param {Array} p_aArgs Collection of arguments sent when the event was fired. 9537 */ 9538 configSubmenuToggle: function (p_sType, p_aArgs) { 9539 9540 var bSubmenuToggle = p_aArgs[0]; 9541 9542 if (bSubmenuToggle) { 9543 9544 this.cfg.setProperty(_AUTO_SUBMENU_DISPLAY, false); 9545 9546 } 9547 9548 }, 9549 9550 9551 /** 9552 * @method toString 9553 * @description Returns a string representing the menu bar. 9554 * @return {String} 9555 */ 9556 toString: function() { 9557 9558 var sReturnVal = _MENUBAR, 9559 sId = this.id; 9560 9561 if(sId) { 9562 9563 sReturnVal += (_SPACE + sId); 9564 9565 } 9566 9567 return sReturnVal; 9568 9569 }, 9570 9571 9572 /** 9573 * @description Initializes the class's configurable properties which can be 9574 * changed using the menu bar's Config object ("cfg"). 9575 * @method initDefaultConfig 9576 */ 9577 initDefaultConfig: function() { 9578 9579 MenuBar.superclass.initDefaultConfig.call(this); 9580 9581 var oConfig = this.cfg; 9582 9583 // Add configuration properties 9584 9585 9586 /* 9587 Set the default value for the "position" configuration property 9588 to "static" by re-adding the property. 9589 */ 9590 9591 9592 /** 9593 * @config position 9594 * @description String indicating how a menu bar should be positioned on the 9595 * screen. Possible values are "static" and "dynamic." Static menu bars 9596 * are visible by default and reside in the normal flow of the document 9597 * (CSS position: static). Dynamic menu bars are hidden by default, reside 9598 * out of the normal flow of the document (CSS position: absolute), and can 9599 * overlay other elements on the screen. 9600 * @default static 9601 * @type String 9602 */ 9603 oConfig.addProperty( 9604 POSITION_CONFIG.key, 9605 { 9606 handler: this.configPosition, 9607 value: POSITION_CONFIG.value, 9608 validator: POSITION_CONFIG.validator, 9609 supercedes: POSITION_CONFIG.supercedes 9610 } 9611 ); 9612 9613 9614 /* 9615 Set the default value for the "submenualignment" configuration property 9616 to ["tl","bl"] by re-adding the property. 9617 */ 9618 9619 /** 9620 * @config submenualignment 9621 * @description Array defining how submenus should be aligned to their 9622 * parent menu bar item. The format is: [itemCorner, submenuCorner]. 9623 * @default ["tl","bl"] 9624 * @type Array 9625 */ 9626 oConfig.addProperty( 9627 SUBMENU_ALIGNMENT_CONFIG.key, 9628 { 9629 value: SUBMENU_ALIGNMENT_CONFIG.value, 9630 suppressEvent: SUBMENU_ALIGNMENT_CONFIG.suppressEvent 9631 } 9632 ); 9633 9634 9635 /* 9636 Change the default value for the "autosubmenudisplay" configuration 9637 property to "false" by re-adding the property. 9638 */ 9639 9640 /** 9641 * @config autosubmenudisplay 9642 * @description Boolean indicating if submenus are automatically made 9643 * visible when the user mouses over the menu bar's items. 9644 * @default false 9645 * @type Boolean 9646 */ 9647 oConfig.addProperty( 9648 AUTO_SUBMENU_DISPLAY_CONFIG.key, 9649 { 9650 value: AUTO_SUBMENU_DISPLAY_CONFIG.value, 9651 validator: AUTO_SUBMENU_DISPLAY_CONFIG.validator, 9652 suppressEvent: AUTO_SUBMENU_DISPLAY_CONFIG.suppressEvent 9653 } 9654 ); 9655 9656 9657 /** 9658 * @config submenutoggleregion 9659 * @description Boolean indicating if only a specific region of a MenuBarItem should toggle the 9660 * display of a submenu. The default width of the region is determined by the value of the 9661 * SUBMENU_TOGGLE_REGION_WIDTH property. If set to true, the autosubmenudisplay 9662 * configuration property will be set to false, and any click event listeners will not be 9663 * called when the user clicks inside the submenu toggle region of a MenuBarItem. If the 9664 * user clicks outside of the submenu toggle region, the MenuBarItem will maintain its 9665 * standard behavior. 9666 * @default false 9667 * @type Boolean 9668 */ 9669 oConfig.addProperty( 9670 SUBMENU_TOGGLE_REGION_CONFIG.key, 9671 { 9672 value: SUBMENU_TOGGLE_REGION_CONFIG.value, 9673 validator: SUBMENU_TOGGLE_REGION_CONFIG.validator, 9674 handler: this.configSubmenuToggle 9675 } 9676 ); 9677 9678 } 9679 9680 }); // END YAHOO.lang.extend 9681 9682 }()); 9683 9684 9685 9686 /** 9687 * Creates an item for a menu bar. 9688 * 9689 * @param {HTML} p_oObject Markup for the menu item content. The markup is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 9690 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9691 * one-html.html#ID-74680021">HTMLLIElement</a>} p_oObject Object specifying the 9692 * <code><li></code> element of the menu bar item. 9693 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9694 * one-html.html#ID-38450247">HTMLOptGroupElement</a>} p_oObject Object 9695 * specifying the <code><optgroup></code> element of the menu bar item. 9696 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9697 * one-html.html#ID-70901257">HTMLOptionElement</a>} p_oObject Object specifying 9698 * the <code><option></code> element of the menu bar item. 9699 * @param {Object} p_oConfig Optional. Object literal specifying the 9700 * configuration for the menu bar item. See configuration class documentation 9701 * for more details. 9702 * @class MenuBarItem 9703 * @constructor 9704 * @extends YAHOO.widget.MenuItem 9705 */ 9706 YAHOO.widget.MenuBarItem = function(p_oObject, p_oConfig) { 9707 9708 YAHOO.widget.MenuBarItem.superclass.constructor.call(this, p_oObject, p_oConfig); 9709 9710 }; 9711 9712 YAHOO.lang.extend(YAHOO.widget.MenuBarItem, YAHOO.widget.MenuItem, { 9713 9714 9715 9716 /** 9717 * @method init 9718 * @description The MenuBarItem class's initialization method. This method is 9719 * automatically called by the constructor, and sets up all DOM references for 9720 * pre-existing markup, and creates required markup if it is not already present. 9721 * @param {HTML} p_oObject Markup for the menu item content. The markup is inserted into the DOM as HTML, and should be escaped by the implementor if coming from an external source. 9722 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9723 * one-html.html#ID-74680021">HTMLLIElement</a>} p_oObject Object specifying the 9724 * <code><li></code> element of the menu bar item. 9725 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9726 * one-html.html#ID-38450247">HTMLOptGroupElement</a>} p_oObject Object 9727 * specifying the <code><optgroup></code> element of the menu bar item. 9728 * @param {<a href="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level- 9729 * one-html.html#ID-70901257">HTMLOptionElement</a>} p_oObject Object specifying 9730 * the <code><option></code> element of the menu bar item. 9731 * @param {Object} p_oConfig Optional. Object literal specifying the 9732 * configuration for the menu bar item. See configuration class documentation 9733 * for more details. 9734 */ 9735 init: function(p_oObject, p_oConfig) { 9736 9737 if(!this.SUBMENU_TYPE) { 9738 9739 this.SUBMENU_TYPE = YAHOO.widget.Menu; 9740 9741 } 9742 9743 9744 /* 9745 Call the init of the superclass (YAHOO.widget.MenuItem) 9746 Note: We don't pass the user config in here yet 9747 because we only want it executed once, at the lowest 9748 subclass level. 9749 */ 9750 9751 YAHOO.widget.MenuBarItem.superclass.init.call(this, p_oObject); 9752 9753 9754 var oConfig = this.cfg; 9755 9756 if(p_oConfig) { 9757 9758 oConfig.applyConfig(p_oConfig, true); 9759 9760 } 9761 9762 oConfig.fireQueue(); 9763 9764 }, 9765 9766 9767 9768 // Constants 9769 9770 9771 /** 9772 * @property CSS_CLASS_NAME 9773 * @description String representing the CSS class(es) to be applied to the 9774 * <code><li></code> element of the menu bar item. 9775 * @default "yuimenubaritem" 9776 * @final 9777 * @type String 9778 */ 9779 CSS_CLASS_NAME: "yuimenubaritem", 9780 9781 9782 /** 9783 * @property CSS_LABEL_CLASS_NAME 9784 * @description String representing the CSS class(es) to be applied to the 9785 * menu bar item's <code><a></code> element. 9786 * @default "yuimenubaritemlabel" 9787 * @final 9788 * @type String 9789 */ 9790 CSS_LABEL_CLASS_NAME: "yuimenubaritemlabel", 9791 9792 9793 9794 // Public methods 9795 9796 9797 /** 9798 * @method toString 9799 * @description Returns a string representing the menu bar item. 9800 * @return {String} 9801 */ 9802 toString: function() { 9803 9804 var sReturnVal = "MenuBarItem"; 9805 9806 if(this.cfg && this.cfg.getProperty("text")) { 9807 9808 sReturnVal += (": " + this.cfg.getProperty("text")); 9809 9810 } 9811 9812 return sReturnVal; 9813 9814 } 9815 9816 }); // END YAHOO.lang.extend 9817 YAHOO.register("menu", YAHOO.widget.Menu, {version: "2.9.0", build: "2800"}); 9818 9819 }, '2.9.0' ,{"requires": ["yui2-yahoo", "yui2-dom", "yui2-event", "yui2-containercore", "yui2-skin-sam-menu"]});
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Thu Aug 11 10:00:09 2016 | Cross-referenced by PHPXref 0.7.1 |