/*!

 * jQuery UI Menu 1.12.1

 * http://jqueryui.com

 *

 * Copyright jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 */

//>>label: Menu

//>>group: Widgets

//>>description: Creates nestable menus.

//>>docs: http://api.jqueryui.com/menu/

//>>demos: http://jqueryui.com/menu/

//>>css.structure: ../../themes/base/core.css

//>>css.structure: ../../themes/base/menu.css

//>>css.theme: ../../themes/base/theme.css

( function( factory ) {

	if ( typeof define === "function" && define.amd ) {

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./core"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

}( function( $ ) {

return $.widget( "ui.menu", {

	version: "1.12.1",

	defaultElement: "<ul>",

	delay: 300,

	options: {

		icons: {

			submenu: "ui-icon-caret-1-e"

		},

		items: "> *",

		menus: "ul",

		position: {

			my: "left top",

			at: "right top"

		},

		role: "menu",

		// Callbacks

		blur: null,

		focus: null,

		select: null

	},

	_create: function() {

		this.activeMenu = this.element;

		// Flag used to prevent firing of the click handler

		// as the event bubbles up through nested menus

		this.mouseHandled = false;

		this.element

			.uniqueId()

			.attr( {

				role: this.options.role,

				tabIndex: 0

			} );

		this._addClass( "ui-menu", "ui-widget ui-widget-content" );

		this._on( {

			// Prevent focus from sticking to links inside menu after clicking

			// them (focus should always stay on UL during navigation).

			"mousedown .ui-menu-item": function( event ) {

				event.preventDefault();

			},

			"click .ui-menu-item": function( event ) {

				var target = $( event.target );

				var active = $( $.ui.safeActiveElement( this.document[ 0 ] ) );

				if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {

					this.select( event );

					// Only set the mouseHandled flag if the event will bubble, see #9469.

					if ( !event.isPropagationStopped() ) {

						this.mouseHandled = true;

					}

					// Open submenu on click

					if ( target.has( ".ui-menu" ).length ) {

						this.expand( event );

					} else if ( !this.element.is( ":focus" ) &&

							active.closest( ".ui-menu" ).length ) {

						// Redirect focus to the menu

						this.element.trigger( "focus", [ true ] );

						// If the active item is on the top level, let it stay active.

						// Otherwise, blur the active item since it is no longer visible.

						if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {

							clearTimeout( this.timer );

						}

					}

				}

			},

			"mouseenter .ui-menu-item": function( event ) {

				// Ignore mouse events while typeahead is active, see #10458.

				// Prevents focusing the wrong item when typeahead causes a scroll while the mouse

				// is over an item in the menu

				if ( this.previousFilter ) {

					return;

				}

				var actualTarget = $( event.target ).closest( ".ui-menu-item" ),

					target = $( event.currentTarget );

				// Ignore bubbled events on parent items, see #11641

				if ( actualTarget[ 0 ] !== target[ 0 ] ) {

					return;

				}

				// Remove ui-state-active class from siblings of the newly focused menu item

				// to avoid a jump caused by adjacent elements both having a class with a border

				this._removeClass( target.siblings().children( ".ui-state-active" ),

					null, "ui-state-active" );

				this.focus( event, target );

			},

			mouseleave: "collapseAll",

			"mouseleave .ui-menu": "collapseAll",

			focus: function( event, keepActiveItem ) {

				// If there's already an active item, keep it active

				// If not, activate the first item

				var item = this.active || this.element.find( this.options.items ).eq( 0 );

				if ( !keepActiveItem ) {

					this.focus( event, item );

				}

			},

			blur: function( event ) {

				this._delay( function() {

					var notContained = !$.contains(

						this.element[ 0 ],

						$.ui.safeActiveElement( this.document[ 0 ] )

					);

					if ( notContained ) {

						this.collapseAll( event );

					}

				} );

			},

			keydown: "_keydown"

		} );

		this.refresh();

		// Clicks outside of a menu collapse any open menus

		this._on( this.document, {

			click: function( event ) {

				if ( this._closeOnDocumentClick( event ) ) {

					this.collapseAll( event );

				}

				// Reset the mouseHandled flag

				this.mouseHandled = false;

			}

		} );

	},

	_destroy: function() {

		var items = this.element.find( ".ui-menu-item" )

				.removeAttr( "role aria-disabled" ),

			submenus = items.children( ".ui-menu-item-wrapper" )

				.removeUniqueId()

				.removeAttr( "tabIndex role aria-haspopup" );

		// Destroy (sub)menus

		this.element

			.removeAttr( "aria-activedescendant" )

			.find( ".ui-menu" ).addBack()

				.removeAttr( "role aria-labelledby aria-expanded aria-hidden aria-disabled " +

					"tabIndex" )

				.removeUniqueId()

				.show();

		submenus.children().each( function() {

			var elem = $( this );

			if ( elem.data( "ui-menu-submenu-caret" ) ) {

				elem.remove();

			}

		} );

	},

	_keydown: function( event ) {

		var match, prev, character, skip,

			preventDefault = true;

		switch ( event.keyCode ) {

		case $.ui.keyCode.PAGE_UP:

			this.previousPage( event );

			break;

		case $.ui.keyCode.PAGE_DOWN:

			this.nextPage( event );

			break;

		case $.ui.keyCode.HOME:

			this._move( "first", "first", event );

			break;

		case $.ui.keyCode.END:

			this._move( "last", "last", event );

			break;

		case $.ui.keyCode.UP:

			this.previous( event );

			break;

		case $.ui.keyCode.DOWN:

			this.next( event );

			break;

		case $.ui.keyCode.LEFT:

			this.collapse( event );

			break;

		case $.ui.keyCode.RIGHT:

			if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {

				this.expand( event );

			}

			break;

		case $.ui.keyCode.ENTER:

		case $.ui.keyCode.SPACE:

			this._activate( event );

			break;

		case $.ui.keyCode.ESCAPE:

			this.collapse( event );

			break;

		default:

			preventDefault = false;

			prev = this.previousFilter || "";

			skip = false;

			// Support number pad values

			character = event.keyCode >= 96 && event.keyCode <= 105 ?

				( event.keyCode - 96 ).toString() : String.fromCharCode( event.keyCode );

			clearTimeout( this.filterTimer );

			if ( character === prev ) {

				skip = true;

			} else {

				character = prev + character;

			}

			match = this._filterMenuItems( character );

			match = skip && match.index( this.active.next() ) !== -1 ?

				this.active.nextAll( ".ui-menu-item" ) :

				match;

			// If no matches on the current filter, reset to the last character pressed

			// to move down the menu to the first item that starts with that character

			if ( !match.length ) {

				character = String.fromCharCode( event.keyCode );

				match = this._filterMenuItems( character );

			}

			if ( match.length ) {

				this.focus( event, match );

				this.previousFilter = character;

				this.filterTimer = this._delay( function() {

					delete this.previousFilter;

				}, 1000 );

			} else {

				delete this.previousFilter;

			}

		}

		if ( preventDefault ) {

			event.preventDefault();

		}

	},

	_activate: function( event ) {

		if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {

			if ( this.active.children( "[aria-haspopup='true']" ).length ) {

				this.expand( event );

			} else {

				this.select( event );

			}

		}

	},

	refresh: function() {

		var menus, items, newSubmenus, newItems, newWrappers,

			that = this,

			icon = this.options.icons.submenu,

			submenus = this.element.find( this.options.menus );

		this._toggleClass( "ui-menu-icons", null, !!this.element.find( ".ui-icon" ).length );

		// Initialize nested menus

		newSubmenus = submenus.filter( ":not(.ui-menu)" )

			.hide()

			.attr( {

				role: this.options.role,

				"aria-hidden": "true",

				"aria-expanded": "false"

			} )

			.each( function() {

				var menu = $( this ),

					item = menu.prev(),

					submenuCaret = $( "<span>" ).data( "ui-menu-submenu-caret", true );

				that._addClass( submenuCaret, "ui-menu-icon", "ui-icon " + icon );

				item

					.attr( "aria-haspopup", "true" )

					.prepend( submenuCaret );

				menu.attr( "aria-labelledby", item.attr( "id" ) );

			} );

		this._addClass( newSubmenus, "ui-menu", "ui-widget ui-widget-content ui-front" );

		menus = submenus.add( this.element );

		items = menus.find( this.options.items );

		// Initialize menu-items containing spaces and/or dashes only as dividers

		items.not( ".ui-menu-item" ).each( function() {

			var item = $( this );

			if ( that._isDivider( item ) ) {

				that._addClass( item, "ui-menu-divider", "ui-widget-content" );

			}

		} );

		// Don't refresh list items that are already adapted

		newItems = items.not( ".ui-menu-item, .ui-menu-divider" );

		newWrappers = newItems.children()

			.not( ".ui-menu" )

				.uniqueId()

				.attr( {

					tabIndex: -1,

					role: this._itemRole()

				} );

		this._addClass( newItems, "ui-menu-item" )

			._addClass( newWrappers, "ui-menu-item-wrapper" );

		// Add aria-disabled attribute to any disabled menu item

		items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );

		// If the active item has been removed, blur the menu

		if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {

			this.blur();

		}

	},

	_itemRole: function() {

		return {

			menu: "menuitem",

			listbox: "option"

		}[ this.options.role ];

	},

	_setOption: function( key, value ) {

		if ( key === "icons" ) {

			var icons = this.element.find( ".ui-menu-icon" );

			this._removeClass( icons, null, this.options.icons.submenu )

				._addClass( icons, null, value.submenu );

		}

		this._super( key, value );