lib/yui/menu/menu.js

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