lib/yui/menu/menu-debug.js

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