lib/yui/menu/menu-debug.js

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