royale-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From GitBox <...@apache.org>
Subject [GitHub] aharui closed pull request #339: Spark Module class added.
Date Wed, 14 Nov 2018 23:19:21 GMT
aharui closed pull request #339: Spark Module class added.
URL: https://github.com/apache/royale-asjs/pull/339
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/frameworks/projects/MXRoyale/src/main/royale/MXRoyaleClasses.as b/frameworks/projects/MXRoyale/src/main/royale/MXRoyaleClasses.as
index 0f67789ed..c67046643 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/MXRoyaleClasses.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/MXRoyaleClasses.as
@@ -148,7 +148,6 @@ internal class MXRoyaleClasses
 	import mx.utils.ByteArray; mx.utils.ByteArray;
 	import mx.controls.RichTextEditor; RichTextEditor;
 	import mx.events.SecurityErrorEvent; SecurityErrorEvent;
-	import mx.events.IOErrorEvent; IOErrorEvent;
 	import mx.events.HTTPStatusEvent; HTTPStatusEvent;
 	import mx.net.FileReference; FileReference;
 	import mx.net.FileFilter; FileFilter;
@@ -190,6 +189,8 @@ internal class MXRoyaleClasses
 	import mx.rpc.CallResponder; CallResponder;
 	import mx.rpc.http.Operation; Operation;
 	import mx.events.TreeEvent; TreeEvent;
+	import mx.messaging.channels.URLVariables; URLVariables;
+	import mx.controls.Menu; Menu;
 	
 
 	COMPILE::JS
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Alert.as b/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Alert.as
index b8f845eb4..b2ef9bffd 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Alert.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Alert.as
@@ -286,7 +286,7 @@ public class Alert extends Panel
      *  @playerversion AIR 1.1
      *  @productversion Royale 0.9.3
      */
-    //public static var buttonWidth:Number = 65;
+    public static var buttonWidth:Number = 65;
     
     //----------------------------------
     //  cancelLabel
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Menu.as b/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Menu.as
new file mode 100644
index 000000000..9be40198c
--- /dev/null
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/controls/Menu.as
@@ -0,0 +1,2641 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package mx.controls
+{
+	
+	import org.apache.royale.events.Event;
+	import org.apache.royale.geom.Rectangle;
+	import org.apache.royale.geom.Point;
+	import mx.core.UIComponent;
+	import mx.events.MouseEvent;
+	
+	/*
+	import flash.display.DisplayObject;
+	import flash.display.DisplayObjectContainer;
+	import flash.events.Event;
+	import flash.events.FocusEvent;
+	import flash.events.KeyboardEvent;
+	import flash.events.MouseEvent;
+	import flash.geom.Point;
+	import flash.geom.Rectangle;
+	import flash.ui.Keyboard;
+	import flash.utils.clearInterval;
+	import flash.utils.setTimeout;
+	import flash.xml.XMLNode;
+	*/
+	
+	import mx.collections.ArrayCollection;
+	import mx.collections.CursorBookmark;
+	import mx.collections.ICollectionView;
+	import mx.collections.XMLListCollection;
+	import mx.controls.listClasses.BaseListData;
+	import mx.controls.listClasses.IListItemRenderer;
+	// import mx.controls.menuClasses.IMenuBarItemRenderer;
+	// import mx.controls.menuClasses.IMenuDataDescriptor;
+	// import mx.controls.menuClasses.IMenuItemRenderer;
+	// import mx.controls.menuClasses.MenuItemRenderer;
+	// import mx.controls.menuClasses.MenuListData;
+	import mx.controls.treeClasses.DefaultDataDescriptor;
+	import mx.core.ClassFactory;
+	import mx.core.EdgeMetrics;
+	import mx.core.EventPriority;
+	import mx.core.FlexGlobals;
+	import mx.core.IFlexDisplayObject;
+	import mx.core.LayoutDirection;
+	import mx.core.ScrollPolicy;
+	import mx.core.UIComponent;
+	import mx.core.UIComponentGlobals;
+	import mx.core.mx_internal;
+	import mx.effects.Tween;
+	import mx.events.CollectionEvent;
+	import mx.events.CollectionEventKind;
+	import mx.events.FlexEvent;
+	// import mx.events.FlexMouseEvent;
+	// import mx.events.InterManagerRequest;
+	import mx.events.ListEvent;
+	import mx.events.MenuEvent;
+	import mx.events.SandboxMouseEvent;
+	import mx.managers.IActiveWindowManager;
+	import mx.managers.IFocusManagerContainer;
+	import mx.managers.ISystemManager;
+	import mx.managers.PopUpManager;
+	
+	use namespace mx_internal;
+	
+	//--------------------------------------
+	//  Events
+	//--------------------------------------
+	
+	/**
+	 *  Dispatched when selection changes as a result
+	 *  of user interaction. 
+	 *
+	 *  @eventType mx.events.MenuEvent.CHANGE
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Event(name="change", type="mx.events.MenuEvent")]
+	
+	/**
+	 *  Dispatched when a menu item is selected. 
+	 *
+	 *  @eventType mx.events.MenuEvent.ITEM_CLICK
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Event(name="itemClick", type="mx.events.MenuEvent")]
+	
+	/**
+	 *  Dispatched when a menu or submenu is dismissed.
+	 *
+	 *  @eventType mx.events.MenuEvent.MENU_HIDE
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Event(name="menuHide", type="mx.events.MenuEvent")]
+	
+	/**
+	 *  Dispatched when a menu or submenu opens. 
+	 *
+	 *  @eventType mx.events.MenuEvent.MENU_SHOW
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Event(name="menuShow", type="mx.events.MenuEvent")]
+	
+	/**
+	 *  Dispatched when a user rolls the mouse out of a menu item.
+	 *
+	 *  @eventType mx.events.MenuEvent.ITEM_ROLL_OUT
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Event(name="itemRollOut", type="mx.events.MenuEvent")]
+	
+	/**
+	 *  Dispatched when a user rolls the mouse over a menu item.
+	 *
+	 *  @eventType mx.events.MenuEvent.ITEM_ROLL_OVER
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Event(name="itemRollOver", type="mx.events.MenuEvent")]
+	
+	//--------------------------------------
+	//  Styles
+	//--------------------------------------
+	
+	/**
+	 *  The colors used for menu or submenu menu items in an alternating pattern. 
+	 *  The value can be an Array of one or more colors.
+	 *  This style is only used if <code>backgroundColor</code> is not specified. 
+	 * 
+	 *  @default "undefined"
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="alternatingItemColors", type="Array", arrayType="uint", format="Color", inherit="yes")]
+	
+	/**
+	 *  Number of pixels between children (icons and label) in the horizontal direction.
+	 * 
+	 *  @default 6
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="horizontalGap", type="Number", format="Length", inherit="no")]
+	
+	/**
+	 *  The gap to the left of the label in a menu item.  If the icons (custom 
+	 *  icon and type icon) do not fit in this gap, the gap is expanded to 
+	 *  fit them properly.
+	 *  The default value is 18.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="leftIconGap", type="Number", format="Length", inherit="no")]
+	
+	/**
+	 *  The gap to the right of the label in a menu item.  If the branch icon 
+	 *  does not fit in this gap, the gap is expanded to fit it properly.
+	 *  The default value is 15.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="rightIconGap", type="Number", format="Length", inherit="no")]
+	
+	/**
+	 *  The duration of the menu or submenu opening transition, in milliseconds.
+	 *  The value 0 specifies no transition.
+	 *  
+	 *  The default value for the Halo theme is 250.
+	 *  The default value for the Spark theme is 0.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="openDuration", type="Number", format="Time", inherit="no")]
+	
+	/**
+	 *  The color of the menu item background when a user rolls the mouse over it. 
+	 *  
+	 *  The default value for the Halo theme is <code>0xB2E1FF</code>.
+	 *  The default value for the Spark theme is <code>0xCEDBEF</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="rollOverColor", type="uint", format="Color", inherit="yes")]
+	
+	/**
+	 *  The color of the menu item background when a menu item is selected.
+	 *  
+	 *  The default value for the Halo theme is <code>0x7FCEFF</code>.
+	 *  The default value for the Spark theme is <code>0xA8C6EE</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="selectionColor", type="uint", format="Color", inherit="yes")]
+	
+	/**
+	 *  The reference to an <code>easingFunction</code> equation which is used to 
+	 *  control programmatic tweening.
+	 * 
+	 *  @default "undefined"
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="selectionEasingFunction", type="Function", inherit="no")]
+	
+	/**
+	 *  The offset of the first line of text from the left side of the menu or 
+	 *  submenu menu item. 
+	 * 
+	 *  @default 0
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="textIndent", type="Number", format="Length", inherit="yes")]
+	
+	/**
+	 *  The color of the menu item text when a user rolls the mouse over the 
+	 *  menu item.
+	 * 
+	 *  The default value for the Halo theme is <code>0x2B333C</code>.
+	 *  The default value for the Spark theme is <code>0x000000</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="textRollOverColor", type="uint", format="Color", inherit="yes")]
+	
+	/**
+	 *  The color of the menu item text when the menu item is selected.
+	 * 
+	 *  The default value for the Halo theme is <code>0x2B333C</code>.
+	 *  The default value for the Spark theme is <code>0x000000</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="textSelectedColor", type="uint", format="Color", inherit="yes")]
+	
+	/**
+	 *  The icon for all enabled menu items that have submenus. 
+	 * 
+	 *  The default value for the Halo theme is the "MenuBranchEnabled" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuArrow</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="branchIcon", type="Class", inherit="no")]
+	
+	/**
+	 *  The icon for all disabled menu items that have submenus. 
+	 * 
+	 *  The default value for the Halo theme is the "MenuBranchDisabled" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuArrowDisabled</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="branchDisabledIcon", type="Class", inherit="no")]
+	
+	/**
+	 *  The icon for all enabled menu items whose type identifier is a check box. 
+	 *  
+	 *  The default value for the Halo theme is the "MenuCheckEnabled" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuCheck</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="checkIcon", type="Class", inherit="no")]
+	
+	/**
+	 *  The icon for all dsiabled menu items whose type identifier is a check box. 
+	 *  
+	 *  The default value for the Halo theme is the "MenuCheckDisabled" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuCheckDisabled</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="checkDisabledIcon", type="Class", inherit="no")]
+	
+	/**
+	 *  The icon for all enabled menu items whose type identifier is a radio 
+	 *  button. 
+	 *  
+	 *  The default value for the Halo theme is the "MenuRadioEnabled" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuRadio</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="radioIcon", type="Class", inherit="no")]
+	
+	/**
+	 *  The icon for all disabled menu items whose type identifier is a radio 
+	 *  button. 
+	 * 
+	 *  The default value for the Halo theme is the "MenuRadioDisabled" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuRadioDisabled</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="radioDisabledIcon", type="Class", inherit="no")]
+	
+	/**
+	 *  The skin for all menu items which are identified as separators. 
+	 *  
+	 *  The default value for the Halo theme is the "MenuSeparator" symbol
+	 *  in the Assets.swf file.
+	 *  The default value for the Spark theme is <code>mx.skins.spark.MenuSeparatorSkin</code>.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	[Style(name="separatorSkin", type="Class", inherit="no")]
+	
+	//--------------------------------------
+	//  Excluded APIs
+	//--------------------------------------
+	
+	[Exclude(name="allowMultipleSelection", kind="property")]
+	[Exclude(name="horizontalScrollBarStyleName", kind="property")]
+	[Exclude(name="horizontalScrollPolicy", kind="property")]
+	[Exclude(name="horizontalScrollPosition", kind="property")]
+	[Exclude(name="liveScrolling", kind="property")]
+	[Exclude(name="maxHorizontalScrollPosition", kind="property")]
+	[Exclude(name="maxVerticalScrollPosition", kind="property")]
+	[Exclude(name="scrollTipFunction", kind="property")]
+	[Exclude(name="showScrollTips", kind="property")]
+	[Exclude(name="verticalScrollBarStyleName", kind="property")]
+	[Exclude(name="verticalScrollPolicy", kind="property")]
+	[Exclude(name="verticalScrollPosition", kind="property")]
+	
+	
+	//--------------------------------------
+	//  Other metadata
+	//--------------------------------------
+	
+	[AccessibilityClass(implementation="mx.accessibility.MenuAccImpl")]
+	
+	[DefaultBindingProperty(destination="dataProvider")]
+	
+	[DefaultTriggerEvent("change")]
+	
+	// [IconFile("Menu.png")]
+	
+	[RequiresDataBinding(true)]
+	
+	/**
+	 *  The Menu control creates a pop-up menu of individually selectable choices,
+	 *  similar to the File or Edit menu found in most software applications. The 
+	 *  popped up menu can have as many levels of submenus as needed. 
+	 *  After a Menu control has opened, it remains visible until it is closed by 
+	 *  any of the following actions:
+	 * 
+	 *  <ul>
+	 *   <li>A call to the <code>Menu.hide()</code> method.</li>
+	 *   <li>When a user selects an enabled menu item.</li>
+	 *   <li>When a user clicks outside of the Menu control.</li>
+	 *   <li>When a user selects another component in the application.</li>
+	 *  </ul>
+	 *
+	 *  <p>The Menu class has no corresponding MXML tag. You must create it using ActionScript.</p>
+	 *
+	 *  <p>The Menu control has the following sizing characteristics:</p>
+	 *     <table class="innertable">
+	 *        <tr>
+	 *           <th>Characteristic</th>
+	 *           <th>Description</th>
+	 *        </tr>
+	 *        <tr>
+	 *           <td>Default size</td>
+	 *           <td>The width is determined from the Menu text. The 
+	 *               default height is the number of menu rows multiplied 
+	 *               by 19 pixels per row (the default row height).</td>
+	 *        </tr>
+	 *     </table>
+	 *
+	 *  <p>The data provider for Menu items can specify several attributes that determine how 
+	 *  the item is displayed and behaves, as the following XML data provider shows:</p>
+	 *  <pre>
+	 *   &lt;mx:XML format=&quot;e4x&quot; id=&quot;myMenuData&quot;&gt;
+	 *     &lt;root&gt;
+	 *        &lt;menuitem label=&quot;MenuItem A&quot; icon=&quot;myTopIcon&quot;&gt;
+	 *            &lt;menuitem label=&quot;SubMenuItem A-1&quot; enabled=&quot;False&quot;/&gt;
+	 *            &lt;menuitem label=&quot;SubMenuItem A-2&quot;/&gt;
+	 *        &lt;/menuitem&gt;
+	 *        &lt;menuitem label=&quot;MenuItem B&quot; type=&quot;check&quot; toggled=&quot;true&quot;/&gt;
+	 *        &lt;menuitem label=&quot;MenuItem C&quot; type=&quot;check&quot; toggled=&quot;false&quot; icon=&quot;myTopIcon&quot;/&gt;
+	 *        &lt;menuitem type=&quot;separator&quot;/&gt; 
+	 *        &lt;menuitem label=&quot;MenuItem D&quot; icon=&quot;myTopIcon&quot;&gt;
+	 *            &lt;menuitem label=&quot;SubMenuItem D-1&quot; type=&quot;radio&quot; groupName=&quot;one&quot;/&gt;
+	 *            &lt;menuitem label=&quot;SubMenuItem D-2&quot; type=&quot;radio&quot; groupName=&quot;one&quot; toggled=&quot;true&quot;/&gt;
+	 *            &lt;menuitem label=&quot;SubMenuItem D-3&quot; type=&quot;radio&quot; groupName=&quot;one&quot;/&gt;
+	 *        &lt;/menuitem&gt;
+	 *    &lt;/root&gt;
+	 * &lt;/mx:XML&gt;</pre>
+	 * 
+	 *  <p>The following table lists the attributes you can specify, 
+	 *  their data types, their purposes, and how the data provider must represent 
+	 *  them if the menu uses the DefaultDataDescriptor class to parse the data provider:</p>
+	 * 
+	 *  <table class="innertable">
+	 *  <tr>
+	 *    <th>Attribute</th>
+	 *    <th>Type</th>
+	 *    <th>Description</th>
+	 *  </tr>
+	 *  <tr>
+	 *    <td><code>enabled</code></td>
+	 *    <td>Boolean</td>
+	 *    <td>Specifies whether the user can select the menu item (<code>true</code>), 
+	 *      or not (<code>false</code>). If not specified, Flex treats the item as if 
+	 *      the value were <code>true</code>.
+	 *      If you use the default data descriptor, data providers must use an <code>enabled</code> 
+	 *      XML attribute or object field to specify this characteristic.</td>
+	 *  </tr>
+	 *  <tr>
+	 *    <td><code>groupName</code></td>
+	 *    <td>String</td>
+	 *    <td> (Required, and meaningful, for <code>radio</code> type only) The identifier that 
+	 *      associates radio button items in a radio group. If you use the default data descriptor, 
+	 *      data providers must use a <code>groupName</code> XML attribute or object field to 
+	 *      specify this characteristic.</td>
+	 *  </tr>
+	 *  <tr>
+	 *    <td><code>icon</code></td>
+	 *    <td>Class</td>
+	 *    <td>Specifies the class identifier of an image asset. This item is not used for 
+	 *      the <code>check</code>, <code>radio</code>, or <code>separator</code> types. 
+	 *      You can use the <code>checkIcon</code> and <code>radioIcon</code> styles to 
+	 *      specify the icons used for radio and check box items that are selected.
+	 *      The menu's <code>iconField</code> or <code>iconFunction</code> property determines 
+	 *      the name of the field in the data that specifies the icon, or a function for determining the icons.</td>
+	 *  </tr>
+	 *  <tr>
+	 *    <td><code>label</code></td>
+	 *    <td>String</td>
+	 *    <td>Specifies the text that appears in the control. This item is used for all 
+	 *      menu item types except <code>separator</code>.
+	 *      The menu's <code>labelField</code> or <code>labelFunction</code> property 
+	 *      determines the name of the field in the data that specifies the label, 
+	 *      or a function for determining the labels. (If the data provider is in E4X XML format, 
+	 *      you must specify one of these properties to display a label.) 
+	 *      If the data provider is an Array of Strings, Flex uses the String value as the label.</td>
+	 *  </tr>
+	 *  <tr>
+	 *    <td><code>toggled</code></td>
+	 *    <td>Boolean</td>
+	 *    <td>Specifies whether a check or radio item is selected. 
+	 *      If not specified, Flex treats the item as if the value were <code>false</code> 
+	 *      and the item is not selected.
+	 *      If you use the default data descriptor, data providers must use a toggled 
+	 *      XML attribute or object field to specify this characteristic.</td>
+	 *  </tr>
+	 *  <tr>
+	 *    <td><code>type</code></td>
+	 *    <td>String</td>
+	 *    <td>Specifies the type of menu item. Meaningful values are <code>separator</code>, 
+	 *      <code>check</code>, or <code>radio</code>. Flex treats all other values, 
+	 *      or nodes with no type entry, as normal menu entries.
+	 *      If you use the default data descriptor, data providers must use a type 
+	 *      XML attribute or object field to specify this characteristic.</td>
+	 *  </tr>
+	 * </table>
+	 *
+	 *
+	 *  @includeExample examples/SimpleMenuExample.mxml
+	 *
+	 *  @see mx.controls.MenuBar
+	 *  @see mx.controls.PopUpMenuButton
+	 *  @see mx.controls.menuClasses.IMenuDataDescriptor
+	 *  @see mx.controls.treeClasses.DefaultDataDescriptor
+	 *  @see mx.effects.Tween
+	 *  @see mx.managers.PopUpManager
+	 *
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Flex 3
+	 */
+	public class Menu extends List implements IFocusManagerContainer
+	{
+		// include "../core/Version.as";
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Class mixins
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Placeholder for mixin by MenuAccImpl.
+		 */
+		mx_internal static var createAccessibilityImplementation:Function;
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Class methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Creates and returns an instance of the Menu class. The Menu control's 
+		 *  content is determined by the method's <code>mdp</code> argument. The 
+		 *  Menu control is placed in the parent container specified by the 
+		 *  method's <code>parent</code> argument.
+		 * 
+		 *  This method does not show the Menu control. Instead, 
+		 *  this method just creates the Menu control and allows for modifications
+		 *  to be made to the Menu instance before the Menu is shown. To show the 
+		 *  Menu, call the <code>Menu.show()</code> method.
+		 *
+		 *  @param parent A container that the PopUpManager uses to place the Menu 
+		 *  control in. The Menu control may not actually be parented by this object.
+		 * 
+		 *  @param mdp The data provider for the Menu control. 
+		 *  @see mx.controls.Menu@dataProvider 
+		 * 
+		 *  @param showRoot A Boolean flag that specifies whether to display the 
+		 *  root node of the data provider.
+		 *  @see mx.controls.Menu@showRoot 
+		 * 
+		 *  @return An instance of the Menu class. 
+		 *
+		 *  @see mx.controls.Menu#popUpMenu()
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public static function createMenu(parent:UIComponent, mdp:Object, showRoot:Boolean = true):Menu
+		{
+			var menu:Menu = new Menu();
+			menu.tabEnabled = false;
+			menu.tabFocusEnabled = false;
+			// menu.owner = DisplayObjectContainer(FlexGlobals.topLevelApplication);
+			menu.showRoot = showRoot;
+			popUpMenu(menu, parent, mdp);
+			return menu;
+		}
+		
+		/**
+		 *  Sets the dataProvider of an existing Menu control and places the Menu 
+		 *  control in the specified parent container.
+		 *  
+		 *  This method does not show the Menu control; you must use the 
+		 *  <code>Menu.show()</code> method to display the Menu control. 
+		 * 
+		 *  The <code>Menu.createMenu()</code> method uses this method.
+		 *
+		 *  @param menu Menu control to popup. 
+		 * 
+		 *  @param parent A container that the PopUpManager uses to place the Menu 
+		 *  control in. The Menu control may not actually be parented by this object.
+		 *  If you omit this property, the method sets the Menu control's parent to 
+		 *  the application. 
+		 * 
+		 *  @param mdp dataProvider object set on the popped up Menu. If you omit this 
+		 *  property, the method sets the Menu data provider to a new, empty XML object.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public static function popUpMenu(menu:Menu, parent:UIComponent, mdp:Object):void
+		{
+			menu.parentDisplayObject = parent ?
+				parent :
+				UIComponent(FlexGlobals.topLevelApplication);
+			
+			if (!mdp)
+				mdp = new XML();
+			
+			menu.supposedToLoseFocus = true;
+			//      menu.isPressed = true;
+			menu.dataProvider = mdp;
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Constructor
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Constructor.
+		 *
+		 *  <p>Applications do not normally call the Menu constructor directly.
+		 *  Instead, Applications will call the <code>Menu.createMenu()</code>
+		 *  method.</p>
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public function Menu()
+		{
+			super();
+			
+			/*itemRenderer = new ClassFactory(MenuItemRenderer);
+			setRowHeight(19);
+			iconField = "icon";*/
+			
+			visible = false;
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Variables
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  internal measuring stick
+		 */
+		private var hiddenItem:IListItemRenderer;
+		
+		/**
+		 *  @private
+		 *  The maximum width for icons.  Used so they 
+		 *  can align properly across all MenuItemRenderers
+		 */
+		private var maxMeasuredIconWidth:Number = 0;
+		
+		/**
+		 *  @private
+		 *  The maximum width for type icons (checkbox, radiobox).
+		 *  Used so they can align properly across all MenuItemRenderers
+		 */
+		private var maxMeasuredTypeIconWidth:Number = 0;
+		
+		/**
+		 *  @private
+		 *  The maximum width for branch icons.  Used so they 
+		 *  can align properly across all MenuItemRenderers
+		 */
+		private var maxMeasuredBranchIconWidth:Number = 0;
+		
+		/**
+		 *  @private
+		 *  Whether the left icons should layout into two separate columns
+		 *  (one for icons and one for type icons, like check and radio)
+		 */
+		private var useTwoColumns:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  The menu bar that eventually spawned this menu
+		 */
+		mx_internal var sourceMenuBar:MenuBar;      // optional
+		
+		/**
+		 *  @private
+		 *  the IMenuBarItemRenderer instance in the menubar 
+		 *  that spawned this menu
+		 */
+		// mx_internal var sourceMenuBarItem:IMenuBarItemRenderer;   // optional
+		
+		/**
+		 *  @private
+		 *  Where to add this menu on the display list.
+		 */
+		mx_internal var parentDisplayObject:UIComponent;
+		
+		/**
+		 *  @private
+		 *  Whether the menu was opened from the left or the right.
+		 *  This really only applies to submenus and helps with cascading submenus.
+		 */
+		private var isDirectionLeft:Boolean = false;
+		
+		// the anchor is the row in the parent menu that opened to be this menu
+		// or the row in this menu that opened to be a submenu
+		private var anchorRow:IListItemRenderer;
+		
+		//private var _anchor:String; // reference to the ID of the last opened submenu within a menu level
+		//private var _anchorIndex:int; // reference to the rowIndex of a menu's anchor in the parent menu
+		
+		private var subMenu:Menu;
+		
+		mx_internal var popupTween:Tween;
+		
+		mx_internal var supposedToLoseFocus:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  When this timer fires, we'll open a submenu
+		 */
+		mx_internal var openSubMenuTimer:int = 0;
+		
+		/**
+		 *  @private
+		 *  When this timer fires, we'll hide this menu
+		 */
+		mx_internal var closeTimer:int = 0;
+		
+		/**
+		 *  @private
+		 *  Storage variable for the original dataProvider
+		 */
+		mx_internal var _rootModel:ICollectionView;
+		
+		/**
+		 *  @private
+		 *  Storage variable for dataProvider passed to parent
+		 */
+		mx_internal var _listDataProvider:ICollectionView;
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Properties
+		//
+		//--------------------------------------------------------------------------
+		
+		//--------------------------------------------------------------------------
+		//  parentMenu
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		mx_internal var _parentMenu:Menu;
+		
+		/**
+		 *  The parent menu in a hierarchical chain of menus, where the current 
+		 *  menu is a submenu of the parent.
+		 * 
+		 *  @return The parent Menu control. 
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public function get parentMenu():Menu
+		{
+			return _parentMenu;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set parentMenu(value:Menu):void
+		{
+			_parentMenu = value;
+			
+			// setup weak references
+			/*value.addEventListener(FlexEvent.HIDE, parentHideHandler, false, 0, true);
+			value.addEventListener("rowHeightChanged", parentRowHeightHandler, false, 0, true);
+			value.addEventListener("iconFieldChanged", parentIconFieldHandler, false, 0, true);
+			value.addEventListener("iconFunctionChanged", parentIconFunctionHandler, false, 0, true);
+			value.addEventListener("labelFieldChanged", parentLabelFieldHandler, false, 0, true);
+			value.addEventListener("labelFunctionChanged", parentLabelFunctionHandler, false, 0, true);
+			value.addEventListener("itemRendererChanged", parentItemRendererHandler, false, 0, true);*/
+		}
+		
+		//--------------------------------------------------------------------------
+		//  dataDescriptor
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		// mx_internal var _dataDescriptor:IMenuDataDescriptor = new DefaultDataDescriptor();
+		
+		/**
+		 *  The object that accesses and manipulates data in the data provider. 
+		 *  The Menu control delegates to the data descriptor for information 
+		 *  about its data. This data is then used to parse and move about the 
+		 *  data source. The data descriptor defined for the root menu is used 
+		 *  for all submenus. 
+		 * 
+		 *  The default value is an internal instance of the
+		 *  DefaultDataDescriptor class.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		/*public function get dataDescriptor():IMenuDataDescriptor
+		{
+			return IMenuDataDescriptor(_dataDescriptor);
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*public function set dataDescriptor(value:IMenuDataDescriptor):void
+		{
+			_dataDescriptor = value;
+		}*/
+		
+		//--------------------------------------------------------------------------
+		//  dataProvider
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		mx_internal var dataProviderChanged:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Convert user data to collection.
+		 *
+		 *  @see mx.controls.listClasses.ListBase
+		 *  @see mx.controls.List
+		 *  @see mx.controls.Tree
+		 */
+		/*override public function set dataProvider(value:Object):void
+		{
+			// handle strings and xml
+			if (typeof(value)=="string")
+				value = new XML(value);
+			else if (value is XMLNode)
+				value = new XML(XMLNode(value).toString());
+			else if (value is XMLList)
+				value = new XMLListCollection(value as XMLList);
+			
+			if (value is XML)
+			{
+				_hasRoot = true;
+				var xl:XMLList = new XMLList();
+				xl += value;
+				_rootModel = new XMLListCollection(xl);
+			}
+				//if already a collection dont make new one
+			else if (value is ICollectionView)
+			{
+				_rootModel = ICollectionView(value);
+				if (_rootModel.length == 1)
+					_hasRoot = true;
+			}
+			else if (value is Array)
+			{
+				_rootModel = new ArrayCollection(value as Array);
+			}
+				//all other types get wrapped in an ArrayCollection
+			else if (value is Object)
+			{
+				_hasRoot = true;
+				// convert to an array containing this one item
+				var tmp:Array = [];
+				tmp.push(value);
+				_rootModel = new ArrayCollection(tmp);
+			}
+			else
+			{
+				_rootModel = new ArrayCollection();
+			}
+			
+			//flag for processing in commitProps
+			dataProviderChanged = true;
+			invalidateProperties();
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		override public function get dataProvider():Object
+		{
+			var model:* = super.dataProvider;
+			if (model == null)
+			{
+				if (_rootModel != null )
+				{
+					return _rootModel;
+				}
+			}
+			else
+			{ 
+				return model;
+			}
+			return null;
+		}
+		
+		//--------------------------------------------------------------------------
+		//  showRoot
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Storage variable for showRoot flag.
+		 */
+		mx_internal var _showRoot:Boolean = true;
+		
+		/**
+		 *  @private
+		 *  Storage variable for changes to showRoot.
+		 */ 
+		mx_internal var showRootChanged:Boolean = false;
+		
+		/**
+		 *  A Boolean flag that specifies whether to display the data provider's 
+		 *  root node.
+		 *
+		 *  If the dataProvider object has a root node, and showRoot is set to 
+		 *  <code>false</code>, the Menu control does not display the root node; 
+		 *  only the descendants of the root node will be displayed.  
+		 * 
+		 *  This flag has no effect on data providers without root nodes, 
+		 *  like Lists and Arrays. 
+		 *
+		 *  @default true
+		 *  @see #hasRoot
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public function get showRoot():Boolean
+		{
+			return _showRoot;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set showRoot(value:Boolean):void
+		{
+			if (_showRoot != value)
+			{
+				_showRoot = value;
+				showRootChanged = true;
+				invalidateProperties();
+			}
+		}
+		
+		//--------------------------------------------------------------------------
+		//  hasRoot
+		//--------------------------------------------------------------------------
+		
+		/** 
+		 *  @private
+		 *  Flag to indicate if the model has a root
+		 */
+		mx_internal var _hasRoot:Boolean = false;
+		
+		/**
+		 *  A flag that indicates that the current data provider has a root node; for example, 
+		 *  a single top node in a hierarchical structure. XML and Object 
+		 *  are examples of types that have a root node, while Lists and Arrays do 
+		 *  not.
+		 * 
+		 *  @default false
+		 *  @see #showRoot
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public function get hasRoot():Boolean
+		{
+			return _hasRoot;
+		}
+		
+		//--------------------------------------------------------------------------
+		//  defaultButton
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		public function get defaultButton():IFlexDisplayObject
+		{
+			return null;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set defaultButton(value:IFlexDisplayObject):void
+		{
+			
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Event handlers
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		private function parentHideHandler(event:FlexEvent):void
+		{
+			visible = false;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function parentRowHeightHandler(event:Event):void
+		{
+			rowHeight = parentMenu.rowHeight;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function parentIconFieldHandler(event:Event):void
+		{
+			// iconField = parentMenu.iconField;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function parentIconFunctionHandler(event:Event):void
+		{
+			// iconFunction = parentMenu.iconFunction;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function parentLabelFieldHandler(event:Event):void
+		{
+			// labelField = parentMenu.labelField;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function parentLabelFunctionHandler(event:Event):void
+		{
+			// labelFunction = parentMenu.labelFunction;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function parentItemRendererHandler(event:Event):void
+		{
+			itemRenderer = parentMenu.itemRenderer;
+		}
+		
+		// -------------------------------------------------------------------------
+		// horizontalScrollPolicy
+		// -------------------------------------------------------------------------
+		
+		[Inspectable(environment="none")]
+		
+		/**
+		 *  @private
+		 */
+		override public function get horizontalScrollPolicy():String
+		{
+			return ScrollPolicy.OFF;
+		}
+		
+		/**
+		 *  @private
+		 */
+		override public function set horizontalScrollPolicy(value:String):void
+		{
+		}
+		
+		// -------------------------------------------------------------------------
+		// verticalScrollPolicy
+		// -------------------------------------------------------------------------
+		
+		[Inspectable(environment="none")]
+		
+		/**
+		 *  @private
+		 */
+		override public function get verticalScrollPolicy():String
+		{
+			return ScrollPolicy.OFF;
+		}
+		
+		/**
+		 *  @private
+		 */
+		override public function set verticalScrollPolicy(value:String):void
+		{
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Overridden methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Called by the initialize() method of UIComponent
+		 *  to hook in the accessibility code.
+		 */
+		/*override protected function initializeAccessibility():void
+		{
+			if (createAccessibilityImplementation != null)
+				createAccessibilityImplementation(this);
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function commitProperties():void 
+		{
+			if (showRootChanged)
+			{
+				if (!_hasRoot)
+					showRootChanged = false;            
+			}
+			
+			if (dataProviderChanged || showRootChanged)
+			{
+				var tmpCollection:ICollectionView;
+				
+				// Reset flags.
+				dataProviderChanged = false;
+				showRootChanged = false;
+				
+				// Are we swallowing the root?
+				if (_rootModel && !_showRoot && _hasRoot)
+				{
+					var rootItem:* = _rootModel.createCursor().current;
+					if (rootItem != null &&
+						_dataDescriptor.isBranch(rootItem, _rootModel) &&
+						_dataDescriptor.hasChildren(rootItem, _rootModel))
+					{
+						// then get rootItem children
+						tmpCollection = _dataDescriptor.getChildren(rootItem, _rootModel);
+					}
+				}
+				
+				if (_listDataProvider)
+				{
+					_listDataProvider.removeEventListener(CollectionEvent.COLLECTION_CHANGE,
+						collectionChangeHandler, false);
+				}
+				
+				// At this point _rootModel may be null so we dont need to continue.
+				if (_rootModel)
+				{
+					if (!tmpCollection)
+						tmpCollection = _rootModel;
+					
+					_listDataProvider = tmpCollection;
+					super.dataProvider = tmpCollection;
+					
+					// not really a default handler, but we need to be later than the wrapper
+					_listDataProvider.addEventListener(CollectionEvent.COLLECTION_CHANGE,
+						collectionChangeHandler,
+						false,
+						EventPriority.DEFAULT_HANDLER, true);
+				}
+				else
+				{
+					_listDataProvider = null;
+					super.dataProvider = null;
+				}
+			}
+			
+			// Send it up the chain.
+			super.commitProperties();
+		}*/
+		
+		
+		/**
+		 *  Calculates the preferred width and height of the Menu based on the
+		 *  widths and heights of its menu items. This method does not take into 
+		 *  account the position and size of submenus. 
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		/*override protected function measure():void
+		{
+			super.measure();
+			
+			if (!dataProvider || dataProvider.length == 0)
+			{
+				// we show a collapsed menu if nothing in it so we can dispatch
+				// a menuShow and give someone a chance to add things
+				measuredWidth = 0;
+				measuredHeight = 0;
+			}
+			else
+			{       
+				var vm:EdgeMetrics = viewMetrics;
+				measuredMinWidth = measuredWidth = measureWidthOfItems(0, dataProvider.length);
+				
+				var requiredHeight:int;
+				if (variableRowHeight)
+					requiredHeight = measureHeightOfItems(0, dataProvider.length);
+				else
+					requiredHeight = dataProvider.length * rowHeight;
+				
+				measuredMinHeight = measuredHeight =
+					requiredHeight + vm.top + vm.bottom;
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override public function measureWidthOfItems(index:int = -1, count:int = 0):Number
+		{
+			var w:Number = 0;
+			
+			// reset max's so we can shrink if we should
+			var minimumLeftMargin:Number = getStyle("leftIconGap");
+			var minimumRightMargin:Number = getStyle("rightIconGap");
+			maxMeasuredIconWidth = 0;
+			maxMeasuredTypeIconWidth = 0;
+			maxMeasuredBranchIconWidth = 0;
+			useTwoColumns = false;
+			
+			if (collection && collection.length)
+			{
+				var placeHolder:CursorBookmark = iterator.bookmark;
+				var previousCount:int = count;
+				
+				// we loop through up to 2 times because the first time, we may 
+				// need to do a re-draw due to the margins changing from a 
+				// larger icon width
+				for (var i:int = 0; i < 2; i++)
+				{
+					iterator.seek(CursorBookmark.FIRST, index);
+					count = previousCount;
+					var valuesChanged:Boolean = false;
+					
+					while (count)
+					{
+						var data:Object = iterator.current;
+						var menuListData:MenuListData;
+						
+						var item:IListItemRenderer = hiddenItem = getMeasuringRenderer(data);
+						item.explicitWidth = NaN;
+						
+						setupRendererFromData(item, data);
+						w = Math.max(item.getExplicitOrMeasuredWidth(), w);
+						
+						if (item is IMenuItemRenderer)
+						{
+							var menuItemRenderer:IMenuItemRenderer = IMenuItemRenderer(item);
+							
+							if (menuItemRenderer.measuredIconWidth > maxMeasuredIconWidth)
+							{
+								maxMeasuredIconWidth = menuItemRenderer.measuredIconWidth;
+								valuesChanged = true;
+							}
+							
+							if (menuItemRenderer.measuredTypeIconWidth > maxMeasuredTypeIconWidth)
+							{
+								maxMeasuredTypeIconWidth = menuItemRenderer.measuredTypeIconWidth;
+								valuesChanged = true;
+							}
+							
+							if (menuItemRenderer.measuredBranchIconWidth > maxMeasuredBranchIconWidth)
+							{
+								maxMeasuredBranchIconWidth = menuItemRenderer.measuredBranchIconWidth;
+								valuesChanged = true;
+							}
+							
+							// use two columns if the same MenuItemRenderer can have both a type icon and a 
+							// regular icon
+							if (menuItemRenderer.measuredIconWidth > 0 && menuItemRenderer.measuredTypeIconWidth)
+							{
+								useTwoColumns = true;
+								valuesChanged = true;
+							}
+						}
+						
+						count--;
+						if (!iterator.moveNext())
+							break;
+					}
+					
+					if (i == 0)
+					{
+						if (!(valuesChanged && 
+							(maxMeasuredIconWidth + maxMeasuredTypeIconWidth > minimumLeftMargin ||
+								maxMeasuredBranchIconWidth > minimumRightMargin)))
+						{
+							break;
+						}
+					}
+				}
+				
+				iterator.seek(placeHolder, 0);
+			}
+			if (!w)
+			{
+				// If we couldn't calculate a width, use 200
+				w = 200;
+			}
+			
+			w += getStyle("paddingLeft") + getStyle("paddingRight");
+			
+			return w;
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function updateDisplayList(unscaledWidth:Number,
+													  unscaledHeight:Number):void
+		{
+			super.updateDisplayList(unscaledWidth, unscaledHeight);
+			
+			if (border)
+			{
+				border.move(0, 0); 
+				border.visible = (dataProvider != null && dataProvider.length > 0);
+			}
+			
+			// there's sort of a bug in the player that if we don't give size to the
+			// hiddenItem it gets set to width = 0 and then you can't measure text anymore.
+			if (hiddenItem)
+				hiddenItem.setActualSize(unscaledWidth, hiddenItem.getExplicitOrMeasuredHeight());
+		}*/
+		
+		/**
+		 *  @private
+		 *  Relying on UIComponent description.
+		 */
+		override public function styleChanged(styleProp:String):void
+		{
+			super.styleChanged(styleProp);
+			
+			deleteDependentSubMenus();
+		}
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function drawItem(item:IListItemRenderer,
+											 selected:Boolean = false,
+											 highlighted:Boolean = false,
+											 caret:Boolean = false,
+											 transition:Boolean = false):void
+		{
+			if (!getStyle("useRollOver"))
+			{
+				super.drawItem(item, selected, false, false, transition);
+			}
+			else
+			{
+				super.drawItem(item, selected, highlighted, caret, transition);
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function configureScrollBars():void
+		{
+		}*/
+		
+		/*override mx_internal function clearHighlight(item:IListItemRenderer):void
+		{
+			var uid:String = itemToUID(item.data);
+			
+			drawItem(visibleData[uid], isItemSelected(item.data),
+				false, uid == caretUID);
+			
+			var pt:Point = itemRendererToIndices(item);
+			if (pt)
+			{
+				var menuEvent:MenuEvent = new MenuEvent(MenuEvent.ITEM_ROLL_OUT);
+				menuEvent.menu = this;
+				menuEvent.index = getRowIndex(item);
+				menuEvent.menuBar = sourceMenuBar;
+				menuEvent.label = itemToLabel(item.data);
+				menuEvent.item = item.data;
+				menuEvent.itemRenderer = item;
+				getRootMenu().dispatchEvent(menuEvent);
+				
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  Determines if the itemrenderer is a separator. If so, return null to prevent separators
+		 *  from highlighting and emitting menu-level events. 
+		 */
+		/*override protected function mouseEventToItemRenderer(event:MouseEvent):IListItemRenderer
+		{
+			var row:IListItemRenderer = super.mouseEventToItemRenderer(event);
+			
+			if (row && row.data && _dataDescriptor.getType(row.data) == "separator")
+				return null;
+			else return row;
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		override public function setFocus():void
+		{
+			super.setFocus();
+		}
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function focusOutHandler(event:FocusEvent):void
+		{
+			super.focusOutHandler(event);
+			if (!supposedToLoseFocus)
+			{
+				hideAllMenus();
+			}
+			supposedToLoseFocus = false;
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override public function dispatchEvent(event:Event):Boolean
+		{  
+			if (!(event is MenuEvent) && event is ListEvent && 
+				(event.type == ListEvent.ITEM_ROLL_OUT ||
+					event.type == ListEvent.ITEM_ROLL_OVER ||
+					event.type == ListEvent.CHANGE))
+			{
+				// we don't want to dispatch ListEvent.ITEM_ROLL_OVER or
+				// ListEvent.ITEM_ROLL_OUT or ListEvent.CHANGE events 
+				// because Menu dispatches its own 
+				event.stopImmediatePropagation();                
+			}   
+			
+			// in case we encounter a ListEvent.ITEM_CLICK from 
+			// a superclass that we did not account for, 
+			// lets convert the ListEvent and pass it on up to 
+			// avoid an RTE
+			if (!(event is MenuEvent) && event is ListEvent && 
+				(event.type == ListEvent.ITEM_CLICK))
+			{
+				var me:MenuEvent = new MenuEvent(event.type,
+					event.bubbles,
+					event.cancelable);
+				me.item = ListEvent(event).itemRenderer.data;
+				me.label = itemToLabel(ListEvent(event).itemRenderer);
+				return super.dispatchEvent(me);                     
+			}
+			
+			// we'll let everything else go through
+			return super.dispatchEvent(event);
+		}*/
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Toggles the menu item. The menu item type identifier must be a
+		 *  check box or radio button, otherwise this method has no effect.
+		 *
+		 *  @param item The menu item to toggle.
+		 *  @param toggle Boolean value that indicates whether the item is 
+		 *  toggled. 
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		protected function setMenuItemToggled(item:Object, toggle:Boolean):void
+		{
+			/*itemsSizeChanged = true;
+			invalidateDisplayList();
+			if (_dataDescriptor.getType(item) == "radio")
+			{
+				var groupName:String = _dataDescriptor.getGroupName(item);
+				
+				// Find other items with the same groupName and toggle them to the state opposite the item.
+				// Toggle the item.
+				for (var i:int = 0; i < listItems.length; i++)
+				{
+					var row:IListItemRenderer = listItems[i][0];
+					var rowItem:Object = row.data;
+					if (_dataDescriptor.getType(rowItem) == "radio" &&
+						_dataDescriptor.getGroupName(rowItem) == groupName)
+					{
+						_dataDescriptor.setToggled(rowItem, (rowItem == item));
+					}
+				}
+			}
+			if (toggle != _dataDescriptor.isToggled(item))
+			{
+				_dataDescriptor.setToggled(item, toggle);
+			}*/
+		}
+		
+		/**
+		 *  Creates a new MenuListData instance and populates the fields based on
+		 *  the input data provider item. 
+		 *  
+		 *  @param data The data provider item used to populate the ListData.
+		 *  @param uid The UID for the item.
+		 *  @param rowNum The index of the item in the data provider.
+		 *  
+		 *  @return A newly constructed ListData object.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		/*override protected function makeListData(data:Object, uid:String, 
+												 rowNum:int):BaseListData
+		{
+			var menuListData:MenuListData = new MenuListData(itemToLabel(data), itemToIcon(data),
+				labelField, uid, this, rowNum);
+			
+			menuListData.maxMeasuredIconWidth = maxMeasuredIconWidth;
+			menuListData.maxMeasuredTypeIconWidth = maxMeasuredTypeIconWidth; 
+			menuListData.maxMeasuredBranchIconWidth = maxMeasuredBranchIconWidth;
+			menuListData.useTwoColumns = useTwoColumns;
+			
+			return menuListData;  
+		}*/
+		
+		/**
+		 *  Shows the Menu control. If the Menu control is not visible, this method 
+		 *  places the Menu in the upper-left corner of the parent application at 
+		 *  the given coordinates, resizes the Menu control as needed, and makes 
+		 *  the Menu control visible.
+		 * 
+		 *  The x and y arguments of the <code>show()</code> method specify the 
+		 *  coordinates of the upper-left corner of the Menu control relative to the 
+		 *  sandbox root, which is not necessarily the direct parent of the 
+		 *  Menu control. 
+		 * 
+		 *  For example, if the Menu control is in an HBox container which is 
+		 *  nested within a Panel container, the x and y coordinates are 
+		 *  relative to the Application container, not to the HBox container.
+		 *
+		 *  @param x Horizontal location of the Menu control's upper-left 
+		 *  corner (optional).
+		 * 
+		 *  @param y Vertical location of the Menu control's upper-left 
+		 *  corner (optional).
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public function show(xShow:Object = null, yShow:Object = null):void
+		{
+			/*//this could be an empty menu so we'll return if it is
+			if (collection && collection.length == 0)
+				return;
+			
+			// If parent is closed, then don't show this submenu
+			if (parentMenu && !parentMenu.visible)
+				return;
+			
+			// If I'm already visible, then do nothing
+			if (visible)
+				return;
+			
+			if (parentDisplayObject && (!parent || !parent.contains(parentDisplayObject)))
+			{
+				PopUpManager.addPopUp(this, parentDisplayObject, false);
+				addEventListener(MenuEvent.MENU_HIDE, menuHideHandler, false, EventPriority.DEFAULT_HANDLER);
+			}
+			
+			// Fire an event
+			var menuEvent:MenuEvent = new MenuEvent(MenuEvent.MENU_SHOW);
+			menuEvent.menu = this;
+			menuEvent.menuBar = sourceMenuBar;
+			getRootMenu().dispatchEvent(menuEvent);
+			
+			// Activate the focus manager for that menu
+			var awm:IActiveWindowManager = 
+				IActiveWindowManager(systemManager.getImplementation("mx.managers::IActiveWindowManager"));
+			awm.activate(this);
+			
+			// Position it
+			if (xShow !== null && !isNaN(Number(xShow)))
+				x = Number(xShow);
+			if (yShow !== null && !isNaN(Number(yShow)))
+				y = Number(yShow);
+			
+			// Adjust for menus that extend out of bounds
+			var sm:ISystemManager = systemManager.topLevelSystemManager;
+			var sbRoot:UIComponent = sm.getSandboxRoot();
+			if (this != getRootMenu())
+			{
+				// do x
+				var screen:Rectangle;
+				var pt:Point = new Point(x, y);
+				pt = sbRoot.localToGlobal(pt);
+				
+				screen = sm.getVisibleApplicationRect(null, true);
+				
+				var shift:Number = pt.x + width - screen.right;
+				if (shift > 0)
+					x = Math.max(x - shift, 0);
+				
+				// now do y
+				shift = pt.y + height - screen.bottom;
+				if (shift > 0)
+					y = Math.max(y - shift, 0);
+			}
+			
+			// Make sure the Menu's width and height has been determined
+			// before we try to set the size for its mask
+			UIComponentGlobals.layoutManager.validateClient(this, true);
+			setActualSize(getExplicitOrMeasuredWidth(), getExplicitOrMeasuredHeight());
+			
+			cacheAsBitmap = true;
+			
+			var duration:Number = getStyle("openDuration");
+			if (duration != 0)
+			{
+				scrollRect = new Rectangle(0, 0, unscaledWidth, 0);
+				
+				// Make it visible
+				visible = true;
+				
+				UIComponentGlobals.layoutManager.validateNow();
+				
+				// Block all layout, responses from web service, and other background
+				// processing until the tween finishes executing.
+				UIComponent.suspendBackgroundProcessing();
+				
+				popupTween = new Tween(this, [0,0], [unscaledWidth,unscaledHeight], duration);
+			}
+			else 
+			{
+				// if duration is zero, this should allow alternate 
+				// effects specified via showEffect to work
+				UIComponentGlobals.layoutManager.validateNow();
+				visible = true;
+			}
+			
+			focusManager.setFocus(this);
+			supposedToLoseFocus = true;
+			
+			// If the user clicks outside the menu, then hide the menu
+			sbRoot.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownOutsideHandler, false, 0, true);
+			addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE, mouseDownOutsideHandler, false, 0, true);*/
+		}
+		
+		/**
+		 *  @private
+		 */
+		mx_internal function onTweenUpdate(value:Object):void
+		{
+			// Slide the mask down until it covers the Menu
+			// scrollRect = new Rectangle(0, 0, value[0], value[1]);
+		}
+		
+		/**
+		 *  @private
+		 */
+		mx_internal function onTweenEnd(value:Object):void
+		{/*
+			UIComponent.resumeBackgroundProcessing();
+			scrollRect = null;
+			popupTween = null;*/
+		}
+		
+		/**
+		 *  Hides the Menu control and any of its submenus if the Menu control is
+		 *  visible.  
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		public function hide():void
+		{/*
+			if (visible)
+			{
+				// Kill any tween that's currently running
+				if (popupTween)
+					popupTween.endTween();
+				
+				clearSelected();
+				if (anchorRow)
+				{
+					drawItem(anchorRow, false, false);
+					anchorRow = null;
+				}
+				
+				visible = false;
+				//          isPressed = false;
+				
+				// Now that the menu is no longer visible, it doesn't need
+				// to listen to mouseDown events anymore.
+				var sbRoot:UIComponent = systemManager.getSandboxRoot();
+				sbRoot.removeEventListener(MouseEvent.MOUSE_DOWN, mouseDownOutsideHandler);
+				removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE, mouseDownOutsideHandler);
+				
+				// Fire an event
+				var menuEvent:MenuEvent = new MenuEvent(MenuEvent.MENU_HIDE);
+				menuEvent.menu = this;
+				menuEvent.menuBar = sourceMenuBar;
+				getRootMenu().dispatchEvent(menuEvent);
+			}*/
+		}
+		
+		// -------------------------------------------------------------------------
+		// Event Handlers
+		// -------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function collectionChangeHandler(event:Event):void
+		{
+			//trace("[Menu] caught model changed:", CollectionEvent(event).kind);
+			if (event is CollectionEvent)
+			{
+				var ce:CollectionEvent = CollectionEvent(event);
+				if (ce.kind == CollectionEventKind.ADD)
+				{
+					super.collectionChangeHandler(event);
+					dataProviderChanged = true;
+					invalidateProperties();
+					invalidateSize();
+					UIComponentGlobals.layoutManager.validateClient(this);
+					setActualSize(getExplicitOrMeasuredWidth(), getExplicitOrMeasuredHeight());
+				}
+				else if (ce.kind == CollectionEventKind.REMOVE)
+				{
+					super.collectionChangeHandler(event);
+					dataProviderChanged = true;
+					invalidateProperties();
+					invalidateSize();
+					UIComponentGlobals.layoutManager.validateClient(this);
+					setActualSize(getExplicitOrMeasuredWidth(), getExplicitOrMeasuredHeight());
+				}
+				else if (ce.kind == CollectionEventKind.REFRESH)
+				{
+					dataProviderChanged = true;
+					invalidateProperties();
+					invalidateSize();
+				}
+				else if (ce.kind == CollectionEventKind.RESET)
+				{
+					dataProviderChanged = true;
+					invalidateProperties();
+					invalidateSize();
+				}
+			}
+			itemsSizeChanged = true;
+			invalidateDisplayList();
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		private function mouseDownOutsideHandler(event:Event):void
+		{/*
+			if (event is MouseEvent)
+			{
+				var mouseEvent:MouseEvent = MouseEvent(event);
+				if (!isMouseOverMenu(mouseEvent) && !isMouseOverMenuBarItem(mouseEvent))
+					hideAllMenus();
+			}
+			else if (event is SandboxMouseEvent)
+				hideAllMenus();*/
+		}
+		
+		/**
+		 *  @private
+		 *  Removes the root menu from the display list.  This is called only for
+		 *  menus created using "createMenu".
+		 * 
+		 *  MJM private static?
+		 */
+		private static function menuHideHandler(event:MenuEvent):void
+		{/*
+			var menu:Menu = Menu(event.target);
+			if (!event.isDefaultPrevented() && event.menu == menu)
+			{
+				menu.supposedToLoseFocus = true;
+				PopUpManager.removePopUp(menu);
+				menu.removeEventListener(MenuEvent.MENU_HIDE, menuHideHandler);
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 *  Handle mouse release on an item.
+		 *
+		 *  For separators or items with sub-menu, do nothing.
+		 *  For check items, toggle state, then fire change event.
+		 *  For radio items, toggle state if untoggled, then fire change event.
+		 *  For normal items, fire change event.
+		 */
+		/*override protected function mouseUpHandler(event:MouseEvent):void
+		{
+			var menuEvent:MenuEvent;
+			
+			if (!enabled || !selectable || !visible)
+				return;
+			
+			super.mouseUpHandler(event);
+			
+			var row:IListItemRenderer = mouseEventToItemRenderer(event);
+			
+			var item:Object;
+			if (row && row.data)
+				item = row.data;
+			
+			if (item != null && _dataDescriptor.isEnabled(item) && !_dataDescriptor.isBranch(item))
+			{
+				// Toggle the item if it is a check or it is previously untoggled radio item.
+				// For previously toggled radio items, we will dispatch MenuEvent.ITEM_CLICK events but
+				// won't toggle or dispatch MenuEvent.CHANGE events.
+				// Custom item renderers can choose how to display this state
+				var toggleItem:Boolean = _dataDescriptor.getType(item) != "radio" 
+					|| !_dataDescriptor.isToggled(item);
+				
+				if (toggleItem)
+					setMenuItemToggled(item, !_dataDescriptor.isToggled(item));
+				
+				menuEvent = new MenuEvent(MenuEvent.ITEM_CLICK);
+				menuEvent.menu = this;
+				menuEvent.index = this.selectedIndex;
+				menuEvent.menuBar = sourceMenuBar;
+				menuEvent.label = itemToLabel(item);
+				menuEvent.item = item;
+				menuEvent.itemRenderer = row;
+				getRootMenu().dispatchEvent(menuEvent);
+				
+				if (toggleItem)
+				{
+					menuEvent = new MenuEvent(MenuEvent.CHANGE);
+					menuEvent.menu = this;
+					menuEvent.index = this.selectedIndex;
+					menuEvent.menuBar = sourceMenuBar;
+					menuEvent.label = itemToLabel(item);
+					menuEvent.item = item;
+					menuEvent.itemRenderer = row;
+					getRootMenu().dispatchEvent(menuEvent);
+				}
+				
+				hideAllMenus();
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  Extend the behavior from ScrollSelectList to handle row presses over
+		 *  separators, branch items, and disabled row items.
+		 */
+		/*override protected function mouseDownHandler(event:MouseEvent):void
+		{
+			var row:IListItemRenderer = mouseEventToItemRenderer(event);
+			
+			var item:Object;
+			if (row && row.data)
+				item = row.data;
+			
+			// only allow action on items that are enabled which are not branches
+			if (item && _dataDescriptor.isEnabled(item) && !_dataDescriptor.isBranch(item))
+				super.mouseDownHandler(event);
+		}*/
+		
+		
+		/**
+		 *  @private
+		 *  Notify listeners when the mouse leaves
+		 */
+		/*override protected function mouseOutHandler(event:MouseEvent):void
+		{
+			if (!enabled || !selectable || !visible) 
+				return;
+			
+			systemManager.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, true);
+			
+			// Fire the appropriate rollout event
+			var row:IListItemRenderer = mouseEventToItemRenderer(event);
+			
+			if (!row)
+				return;
+			
+			var item:Object;
+			if (row && row.data)
+				item = row.data;
+			
+			// If a submenu was waiting to open, then clear the timeout
+			// so it doesn't open
+			if (openSubMenuTimer)
+			{
+				clearInterval(openSubMenuTimer);
+				openSubMenuTimer = 0;
+			}
+			
+			// either we're rolling onto different subpieces of ourself or our 
+			// highlight indicator, or the clearing of the highlighted item has 
+			// already happened care of the mouseMove handler
+			if (itemRendererContains(row, event.relatedObject) ||
+				itemRendererContains(row, UIComponent(event.target)) || 
+				event.relatedObject == highlightIndicator || 
+				event.relatedObject == listContent || 
+				!highlightItemRenderer)
+			{
+				return;
+			}
+			
+			if (getStyle("useRollOver") && item)
+			{
+				clearHighlight(row);
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  Extend the behavior from ScrollSelectList to pop up submenus
+		 */
+		/*override protected function mouseOverHandler(event:MouseEvent):void
+		{
+			if (!enabled || !selectable || !visible) 
+				return;
+			
+			systemManager.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, true, 0, true);
+			
+			var row:IListItemRenderer = mouseEventToItemRenderer(event);
+			
+			if (!row)
+				return;
+			
+			var item:Object;
+			if (row && row.data)
+				item = row.data;
+			
+			isPressed = event.buttonDown;
+			
+			if (row && row != anchorRow)
+			{
+				if (anchorRow)
+					// no longer on anchor so close its submenu
+					drawItem(anchorRow, false, false);
+				if (subMenu)
+				{
+					subMenu.supposedToLoseFocus = true;
+					subMenu.closeTimer = setTimeout(closeSubMenu, 250, subMenu);
+				}
+				subMenu = null;
+				anchorRow = null;
+			}
+			else if (subMenu && subMenu.subMenu)
+			{
+				// Close grandchild submenus - only children are allowed to be open
+				subMenu.subMenu.hide();
+			}
+			
+			// Update the view
+			if (_dataDescriptor.isBranch(item) && _dataDescriptor.isEnabled(item))
+			{
+				anchorRow = row;
+				
+				// If there's a timer waiting to close this menu, cancel the
+				// timer so that the menu doesn't close
+				if (subMenu && subMenu.closeTimer)
+				{
+					clearInterval(subMenu.closeTimer);
+					subMenu.closeTimer = 0;
+				}
+				
+				// If the menu is not visible, pop it up after a short delay
+				if (!subMenu || !subMenu.visible)
+				{
+					if (openSubMenuTimer)
+						clearInterval(openSubMenuTimer);
+					
+					openSubMenuTimer = setTimeout(
+						function(row:IListItemRenderer):void
+						{
+							openSubMenu(row);
+						},
+						250,
+						row);
+				}
+			}
+			
+			// Send event and update view
+			if (item && _dataDescriptor.isEnabled(item))
+			{
+				// we're rolling onto different subpieces of ourself or our highlight indicator
+				if (event.relatedObject)
+				{
+					if (itemRendererContains(row, event.relatedObject) ||
+						row == lastHighlightItemRenderer ||
+						event.relatedObject == highlightIndicator)
+						return;
+				}
+			}
+			
+			if (row)
+			{
+				drawItem(row, false, Boolean(item && _dataDescriptor.isEnabled(item)));
+				
+				if (isPressed)
+				{
+					if (item && _dataDescriptor.isEnabled(item))
+					{
+						if (!_dataDescriptor.isBranch(item))
+							selectItem(row, event.shiftKey, event.ctrlKey);
+						else
+							clearSelected();
+					}
+				}
+				
+				if (item && _dataDescriptor.isEnabled(item))
+				{
+					// Fire the appropriate rollover event
+					var menuEvent:MenuEvent = new MenuEvent(MenuEvent.ITEM_ROLL_OVER);
+					menuEvent.menu = this;
+					menuEvent.index = getRowIndex(row);
+					menuEvent.menuBar = sourceMenuBar;
+					menuEvent.label = itemToLabel(item);
+					menuEvent.item = item;
+					menuEvent.itemRenderer = row;
+					getRootMenu().dispatchEvent(menuEvent);
+				}
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  ListBase uses the mouseClickHandler dispatch the ListEvent.ITEM_CLICK event.
+		 *  In Menu we chose to do that in the mouseUpHandler so we will do nothing
+		 *  in the mouseClickHandler. 
+		 */
+		/*override protected function mouseClickHandler(event:MouseEvent):void
+		{
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function keyDownHandler(event:KeyboardEvent):void
+		{
+			var row:IListItemRenderer = selectedIndex == -1 ? null : listItems[selectedIndex - verticalScrollPosition][0];
+			var rowData:Object = row ? row.data : null;
+			var menu:Menu = row ? IMenuItemRenderer(row).menu : null;
+			var menuEvent:MenuEvent;
+			
+			// If rtl layout, need to swap LEFT and RIGHT so correct action
+			// is done.
+			var keyCode:uint = mapKeycodeForLayoutDirection(event);
+			
+			// Handle Key.UP Navigation
+			if (keyCode == Keyboard.UP)
+			{
+				if (rowData && _dataDescriptor.isBranch(rowData) && menu && menu.visible)
+				{
+					supposedToLoseFocus = true;
+					menu.setFocus();
+					
+					// start at end and move up 1
+					menu.moveSelBy(menu.dataProvider.length, -1);
+				}
+				else
+				{
+					moveSelBy(selectedIndex, -1);
+				}
+				
+				event.stopPropagation();
+			}
+				
+				// Handle Key.DOWN Navigation
+			else if (keyCode == Keyboard.DOWN)
+			{
+				if (rowData && _dataDescriptor.isBranch(rowData) && menu && menu.visible)
+				{
+					supposedToLoseFocus = true;
+					menu.setFocus();
+					
+					// start at -1 and move down 1
+					menu.moveSelBy(-1, 1);
+				}
+				else
+				{
+					moveSelBy(selectedIndex, 1);
+				}
+				
+				event.stopPropagation();
+			}
+				
+				// Handle Key.RIGHT Navigation
+			else if (keyCode == Keyboard.RIGHT)
+			{
+				if (rowData && _dataDescriptor.isBranch(rowData))
+				{
+					openSubMenu(row);
+					menu = IMenuItemRenderer(row).menu;
+					
+					supposedToLoseFocus = true;
+					menu.setFocus();
+					
+					// start at -1 and move down 1
+					menu.moveSelBy(-1, 1);
+				}
+				else
+				{
+					// jump to next sibling in the menubar
+					if (sourceMenuBar)
+					{
+						supposedToLoseFocus = true;
+						sourceMenuBar.setFocus();
+						// Redispatch the event to the MenuBar
+						// and let its keyDownHandler() handle it.
+						sourceMenuBar.dispatchEvent(event);
+					}
+				}
+				event.stopPropagation();
+			}
+				
+				// Handle Key.LEFT Navigation
+			else if (keyCode == Keyboard.LEFT)
+			{
+				if (_parentMenu)
+				{
+					supposedToLoseFocus = true;
+					hide(); // hide this menu
+					_parentMenu.setFocus();
+				}
+				else
+				{
+					// jump to previous sibling in the menubar
+					if (sourceMenuBar)
+					{
+						supposedToLoseFocus = true;
+						sourceMenuBar.setFocus();
+						// Redispatch the event to the MenuBar
+						// and let its keyDownHandler() handle it.
+						sourceMenuBar.dispatchEvent(event);
+					}
+				}
+				
+				event.stopPropagation();
+			}
+				
+				// Handle Key.ENTER Commands
+			else if (keyCode == Keyboard.ENTER || keyCode == Keyboard.SPACE)
+			{
+				if (rowData && _dataDescriptor.isBranch(rowData))
+				{
+					openSubMenu(row);
+					menu = IMenuItemRenderer(row).menu;
+					
+					supposedToLoseFocus = true;
+					menu.setFocus();
+					
+					// start at -1 and move down 1
+					menu.moveSelBy(-1, 1);
+				}
+				else if (rowData)
+				{
+					// Toggle the item regardless of whether it is a check or radio
+					// Custom item renderers can choose how to display this state
+					setMenuItemToggled(rowData, !_dataDescriptor.isToggled(rowData));
+					
+					menuEvent = new MenuEvent(MenuEvent.ITEM_CLICK);
+					menuEvent.menu = this;
+					menuEvent.index = this.selectedIndex;
+					menuEvent.menuBar = sourceMenuBar;
+					menuEvent.label = itemToLabel(rowData);
+					menuEvent.item = rowData;
+					menuEvent.itemRenderer = row;
+					getRootMenu().dispatchEvent(menuEvent);
+					
+					menuEvent = new MenuEvent(MenuEvent.CHANGE);
+					menuEvent.menu = this;
+					menuEvent.index = this.selectedIndex;
+					menuEvent.menuBar = sourceMenuBar;
+					menuEvent.label = itemToLabel(rowData);
+					menuEvent.item = rowData;
+					menuEvent.itemRenderer = row;
+					getRootMenu().dispatchEvent(menuEvent);
+					
+					hideAllMenus();
+				}
+				
+				event.stopPropagation();
+			}
+				
+				// Handle Key.ESCAPE commands
+			else if (keyCode == Keyboard.TAB)
+			{
+				menuEvent = new MenuEvent(MenuEvent.MENU_HIDE);
+				menuEvent.menu = getRootMenu();
+				menuEvent.menuBar = sourceMenuBar;
+				getRootMenu().dispatchEvent(menuEvent);
+				
+				hideAllMenus();
+				
+				event.stopPropagation();
+			}
+				
+			else if (keyCode == Keyboard.ESCAPE)
+			{
+				if (_parentMenu)
+				{
+					supposedToLoseFocus = true;
+					hide(); // hide this menu
+					_parentMenu.setFocus();
+				}
+				else
+				{
+					menuEvent = new MenuEvent(MenuEvent.MENU_HIDE);
+					menuEvent.menu = getRootMenu();
+					menuEvent.menuBar = sourceMenuBar;
+					getRootMenu().dispatchEvent(menuEvent);
+					
+					hideAllMenus();
+					
+					event.stopPropagation();
+				}
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		private function moveSelBy(oldIndex:Number, incr:Number):void
+		{/*
+			var curIndex:Number = oldIndex;
+			if (isNaN(curIndex))
+				curIndex = -1;
+			
+			var limit:Number = Math.max(0, Math.min(rowCount, collection.length) - 1);
+			
+			var newIndex:Number = curIndex;
+			var item:Object;
+			var curItem:int = 0;
+			
+			do
+			{ 
+				newIndex = newIndex + incr;
+				
+				if (curItem > limit)
+					return;
+				else
+					curItem++;
+				
+				if (newIndex > limit)
+					newIndex = 0;
+				else if (newIndex < 0)
+					newIndex = limit;
+				
+				item = listItems[newIndex][0];
+				
+			}
+			while (item.data && (_dataDescriptor.getType(item.data) == "separator" || !_dataDescriptor.isEnabled(item.data)));
+			
+			var menuEvent:MenuEvent;
+			
+			if (selectedIndex != -1)
+			{
+				var oldItem:Object = listItems[selectedIndex][0];
+				
+				menuEvent = new MenuEvent(MenuEvent.ITEM_ROLL_OUT);
+				menuEvent.menu = this;
+				menuEvent.index = this.selectedIndex;
+				menuEvent.menuBar = sourceMenuBar;
+				menuEvent.label = itemToLabel(oldItem.data);
+				menuEvent.item = oldItem.data;
+				menuEvent.itemRenderer = IListItemRenderer(oldItem);
+				getRootMenu().dispatchEvent(menuEvent);
+			}
+			
+			if (item.data)
+			{
+				selectItem(listItems[newIndex - verticalScrollPosition][0], false, false);
+				
+				menuEvent = new MenuEvent(MenuEvent.ITEM_ROLL_OVER);
+				menuEvent.menu = this;
+				menuEvent.index = this.selectedIndex;
+				menuEvent.menuBar = sourceMenuBar;
+				menuEvent.label = itemToLabel(item.data);
+				menuEvent.item = item.data;
+				menuEvent.itemRenderer = IListItemRenderer(item);
+				getRootMenu().dispatchEvent(menuEvent);
+			}*/
+		}
+		
+		// -------------------------------------------------------------------------
+		// Menu visibility management
+		// -------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		mx_internal function openSubMenu(row:IListItemRenderer):void
+		{
+			supposedToLoseFocus = true;
+			
+			var r:Menu = getRootMenu();
+			var menu:Menu;
+			
+			// check to see if the menu exists, if not create it
+			/*if (!IMenuItemRenderer(row).menu)
+			{
+				menu = new Menu();
+				menu.parentMenu = this;
+				menu.owner = this;
+				menu.showRoot = showRoot;
+				menu.dataDescriptor = r.dataDescriptor;
+				menu.styleName = r;
+				menu.labelField = r.labelField;
+				menu.labelFunction = r.labelFunction;
+				menu.iconField = r.iconField;
+				menu.iconFunction = r.iconFunction;
+				menu.itemRenderer = r.itemRenderer;
+				menu.rowHeight = r.rowHeight;
+				menu.scaleY = r.scaleY;
+				menu.scaleX = r.scaleX;
+				
+				// if there's data and it has children then add the items
+				if (row.data && 
+					_dataDescriptor.isBranch(row.data) &&
+					_dataDescriptor.hasChildren(row.data))
+				{
+					menu.dataProvider = _dataDescriptor.getChildren(row.data);
+				}
+				menu.sourceMenuBar = sourceMenuBar;
+				menu.sourceMenuBarItem = sourceMenuBarItem;
+				
+				IMenuItemRenderer(row).menu = menu;
+				PopUpManager.addPopUp(menu, r, false);
+			}
+			else
+			{
+				menu = IMenuItemRenderer(row).menu;
+			}
+			
+			var _do:UIComponent = UIComponent(row);
+			var sandBoxRootPoint:Point = new Point(0,0);
+			sandBoxRootPoint = _do.localToGlobal(sandBoxRootPoint);
+			// when loadMovied, you may not be in global coordinates
+			if (_do.root)   //verify this is sufficient
+				sandBoxRootPoint = _do.root.globalToLocal(sandBoxRootPoint);
+			
+			// If the layout is mirrored, and isDirectionLeft then we add the
+			// menu's width to find the origin of menu, rather than subtracting.
+			// Similarly, if isDirectionLeft=false, we subtract the menu item's width.
+			
+			const isLayoutMirrored:Boolean = 
+				(layoutDirection == LayoutDirection.RTL);
+			const menuWidth:Number = menu.getExplicitOrMeasuredWidth();
+			const menuItemWidth:Number = row.width;
+			
+			// showX, showY are in sandbox root coordinates
+			var showY:Number = sandBoxRootPoint.y;
+			var showX:Number;
+			if (!isDirectionLeft)
+				showX = sandBoxRootPoint.x + ((isLayoutMirrored) ? -menuItemWidth : +menuItemWidth);
+			else
+				showX = sandBoxRootPoint.x + ((isLayoutMirrored) ? +menuWidth : -menuWidth);
+			
+			// If the layout has been mirrored, then showX is currently menu's right
+			// edge; compensate here.
+			if (isLayoutMirrored)
+				showX -= menuWidth;
+			
+			// convert to global coordinates to compare with getVisibleApplicationRect().
+			// the screen is the visible coordinates of our sandbox (written in global coordinates)
+			var screen:Rectangle = systemManager.getVisibleApplicationRect(null, true);
+			var sbRoot:UIComponent = systemManager.getSandboxRoot();
+			
+			var screenPoint:Point = sbRoot.localToGlobal(new Point(showX, showY));
+			
+			// do x
+			var shift:Number = screenPoint.x + menuWidth - screen.right;
+			if (shift > 0 || screenPoint.x < screen.x)
+			{
+				// if we want to ensure our parent's visible, let's 
+				// modify the shift so that we're not just on-screen
+				// but we're also shifted away from our parent.
+				var shiftForParent:Number = getExplicitOrMeasuredWidth() + menu.getExplicitOrMeasuredWidth();
+				
+				// if was going left, shift to right.  otherwise, shift to left
+				if (isDirectionLeft)
+					shiftForParent *= -1;
+				
+				showX = Math.max(showX - shiftForParent, 0);
+				
+				// now make sure we're still on-screen again
+				screenPoint = new Point(showX, showY);
+				screenPoint = sbRoot.localToGlobal(screenPoint);
+				
+				// only shift if greater our position + width > width of screen
+				shift = Math.max(0, screenPoint.x + width - screen.right);
+				
+				showX = Math.max(showX - shift, 0);
+			}
+			
+			menu.isDirectionLeft = (isLayoutMirrored) ? (this.x <= showX) : (this.x > showX);
+			
+			// now do y
+			shift = screenPoint.y + menu.getExplicitOrMeasuredHeight() - screen.bottom;
+			if (shift > 0 || screenPoint.y < screen.y)
+				showY = Math.max(showY - shift, 0);
+			
+			menu.show(showX, showY);
+			
+			subMenu = menu;
+			clearInterval(openSubMenuTimer);
+			openSubMenuTimer = 0;*/
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function closeSubMenu(menu:Menu):void
+		{
+			menu.hide();
+			// clearInterval(menu.closeTimer);
+			menu.closeTimer = 0;
+		}
+		
+		mx_internal function deleteDependentSubMenus():void
+		{/*
+			var n:int = listItems.length;
+			for (var i:int = 0; i < n; i++)
+			{
+				
+				// Check to see if the listItems array has a renderer at this index.
+				if (listItems[i][0])
+				{
+					var subMenu:Menu = IMenuItemRenderer(listItems[i][0]).menu;
+					if (subMenu)
+					{
+						subMenu.deleteDependentSubMenus();
+						PopUpManager.removePopUp(subMenu);
+						IMenuItemRenderer(listItems[i][0]).menu = null;
+					}
+				}
+			}*/
+		}
+		
+		mx_internal function hideAllMenus():void
+		{
+			getRootMenu().hide();
+			getRootMenu().deleteDependentSubMenus();
+		}
+		
+		//--------------------------------------------------------------------------
+		// Internal utilities
+		//--------------------------------------------------------------------------
+		
+		private function isMouseOverMenu(event:MouseEvent):Boolean
+		{
+			var target:UIComponent = UIComponent(event.target);
+			while (target)
+			{
+				if (target is Menu)
+					return true;
+				// target = target.parent;
+			}
+			
+			return false;
+		}
+		
+		private function isMouseOverMenuBarItem(event:MouseEvent):Boolean
+		{
+			/*if (!sourceMenuBarItem)
+				return false;
+			
+			var target:UIComponent = UIComponent(event.target);
+			while (target)
+			{
+				if (target == sourceMenuBarItem)
+					return true;
+				target = target.parent;
+			}*/
+			
+			return false;
+		}
+		
+		/**
+		 * From any menu, walks up the parent menu chain and finds the root menu.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		mx_internal function getRootMenu():Menu
+		{
+			var target:Menu = this;
+			
+			while (target.parentMenu)
+				target = target.parentMenu;
+			
+			return target;
+		}
+		
+		/**
+		 * Given a row, find the row's index in the Menu. 
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		private function getRowIndex(row:IListItemRenderer):int
+		{
+			/*for (var i:int = 0; i < listItems.length; i++)
+			{
+				var item:IListItemRenderer = listItems[i][0];
+				if (item && item.data && !(_dataDescriptor.getType(item.data) == "separator"))
+					if (item == row)
+						return i;
+			}*/
+			return -1;
+		}
+		
+		/**
+		 *  For autotesting, get the current set of submenus
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Flex 3
+		 */
+		mx_internal function get subMenus():Array
+		{
+			var arr:Array = [];
+			/*for (var i:int = 0; i < listItems.length; i++)
+			{
+				arr.push(listItems[i][0].menu);
+			}*/
+			return arr;
+		}
+		
+	}
+	
+}
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/core/ScrollControlBase.as b/frameworks/projects/MXRoyale/src/main/royale/mx/core/ScrollControlBase.as
index 33962495a..ff40934c4 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/core/ScrollControlBase.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/core/ScrollControlBase.as
@@ -239,7 +239,7 @@ public class ScrollControlBase extends UIComponent
      *  @private
      */
 //    mx_internal var _maxVerticalScrollPosition:Number;
-//    mx_internal var _maxHorizontalScrollPosition:Number;
+    mx_internal var _maxHorizontalScrollPosition:Number;
 
     /**
      *  @private
@@ -261,7 +261,7 @@ public class ScrollControlBase extends UIComponent
      *  @playerversion AIR 1.1
      *  @productversion Flex 3
      */
-//    protected var scrollAreaChanged:Boolean;
+    protected var scrollAreaChanged:Boolean;
 
     /**
      *  @private
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/events/EffectEvent.as b/frameworks/projects/MXRoyale/src/main/royale/mx/events/EffectEvent.as
index 6e5eabb60..da1fee24b 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/events/EffectEvent.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/events/EffectEvent.as
@@ -118,8 +118,8 @@ public class EffectEvent extends Event
      *  @playerversion AIR 1.1
      *  @productversion Royale 0.9.3
      */
-/*     public static const EFFECT_STOP:String = "effectStop";
- */    
+     public static const EFFECT_STOP:String = "effectStop";
+    
 	/**
      *  The <code>EffectEvent.EFFECT_START</code> constant defines the value of the 
      *  <code>type</code> property of the event object for an 
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/events/FlexEvent.as b/frameworks/projects/MXRoyale/src/main/royale/mx/events/FlexEvent.as
index d9fcaccce..ca1536fca 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/events/FlexEvent.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/events/FlexEvent.as
@@ -1189,7 +1189,7 @@ public class FlexEvent extends Event
      *  @playerversion AIR 2.5
      *  @productversion Flex 4.5
      */
-    //public static const STATE_CHANGE_COMPLETE:String = "stateChangeComplete";
+    public static const STATE_CHANGE_COMPLETE:String = "stateChangeComplete";
     
     /**
      *  The <code>FlexEvent.STATE_CHANGE_INTERRUPTED</code> constant defines the value of the
@@ -1341,7 +1341,7 @@ public class FlexEvent extends Event
      *  @playerversion AIR 1.1
      *  @productversion Royale 0.9.3
      */
-    //public static const UPDATE_COMPLETE:String = "updateComplete";
+    public static const UPDATE_COMPLETE:String = "updateComplete";
 
     /**
      *  The <code>FlexEvent.URL_CHANGED</code> constant defines the value of the
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/events/HTTPStatusEvent.as b/frameworks/projects/MXRoyale/src/main/royale/mx/events/HTTPStatusEvent.as
index 0a260ee8d..e1a5dc2d2 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/events/HTTPStatusEvent.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/events/HTTPStatusEvent.as
@@ -39,6 +39,8 @@ import org.apache.royale.events.IRoyaleEvent;
 COMPILE::SWF
 public class HTTPStatusEvent extends flash.events.HTTPStatusEvent
 {
+	public static const HTTP_STATUS:String = "httpStatus";
+	
 	public function HTTPStatusEvent(type:String, bubbles:Boolean = false, 
 	 cancelable:Boolean = false, status:int = 0)
 	{
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/events/IOErrorEvent.as b/frameworks/projects/MXRoyale/src/main/royale/mx/events/IOErrorEvent.as
index 86dd1756e..6bda6a601 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/events/IOErrorEvent.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/events/IOErrorEvent.as
@@ -39,6 +39,8 @@ import org.apache.royale.events.IRoyaleEvent;
 COMPILE::SWF
 public class IOErrorEvent extends flash.events.IOErrorEvent
 {
+	public static const IO_ERROR:String = "ioError";
+	
 	public function IOErrorEvent(type:String, bubbles:Boolean = false,
 							  cancelable:Boolean = false, text:String = "", id:int = 0
 							  )
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/events/MenuEvent.as b/frameworks/projects/MXRoyale/src/main/royale/mx/events/MenuEvent.as
index 595cc2205..90e701849 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/events/MenuEvent.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/events/MenuEvent.as
@@ -146,7 +146,7 @@ public class MenuEvent extends ListEvent
      *  @playerversion AIR 1.1
      *  @productversion Royale 0.9.3
      */
-    //public static const ITEM_CLICK:String = "itemClick";
+    public static const ITEM_CLICK:String = "itemClick";
 
     /**
      *  The MenuEvent.MENU_HIDE event type constant indicates that
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/events/SecurityErrorEvent.as b/frameworks/projects/MXRoyale/src/main/royale/mx/events/SecurityErrorEvent.as
index a5cfb1722..1db14915f 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/events/SecurityErrorEvent.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/events/SecurityErrorEvent.as
@@ -39,6 +39,8 @@ import org.apache.royale.events.IRoyaleEvent;
 COMPILE::SWF
 public class SecurityErrorEvent extends flash.events.SecurityErrorEvent
 {
+	public static const SECURITY_ERROR:String = "securityError";
+	
 	public function SecurityErrorEvent(type:String, bubbles:Boolean = false, 
 	cancelable:Boolean = false, text:String = "", id:int = 0)
 	{
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManager.as b/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManager.as
index abe560232..9c2037c23 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManager.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManager.as
@@ -406,10 +406,10 @@ public class CursorManager
      *  @playerversion AIR 1.1
      *  @productversion Royale 0.9.3
      */
-    /* public static function setBusyCursor():void 
+    public static function setBusyCursor():void 
     {
-        impl.setBusyCursor();
-    } */
+        // impl.setBusyCursor();
+    }
 
     /**
      *  Removes the busy cursor from the cursor list.
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManagerPriority.as b/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManagerPriority.as
index a3f6ecfe3..ac04764ed 100644
--- a/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManagerPriority.as
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/managers/CursorManagerPriority.as
@@ -20,32 +20,62 @@
 package mx.managers
 {
 	
-/**
- *  The CursorManagerPriority class defines the constant values for the 
- *  <code>priority</code> argument to the 
- *  <code>CursorManager.setCursor()</code> method. 
- *
- *  @see mx.managers.CursorManager
- *  
- *  @langversion 3.0
- *  @playerversion Flash 9
- *  @playerversion AIR 1.1
- *  @productversion Royale 0.9.3
- */
-public final class CursorManagerPriority
-{
-	//include "../core/Version.as";
-
-	//--------------------------------------------------------------------------
-	//
-	//  Class constants
-	//
-	//--------------------------------------------------------------------------
-
-	
-	public static const MEDIUM:int = 2;
+	/**
+	 *  The CursorManagerPriority class defines the constant values for the 
+	 *  <code>priority</code> argument to the 
+	 *  <code>CursorManager.setCursor()</code> method. 
+	 *
+	 *  @see mx.managers.CursorManager
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Royale 0.9.3
+	 */
+	public final class CursorManagerPriority
+	{
+		//include "../core/Version.as";
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Class constants
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Constant that specifies the highest cursor priority when passed
+		 *  as the <code>priority</code> argument to <code>setCursor()</code>.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Royale 0.9.3
+		 */
+		public static const HIGH:int = 1;
+		
+		/**
+		 *  Constant that specifies a medium cursor priority when passed 
+		 *  as the <code>priority</code> argument to <code>setCursor()</code>.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Royale 0.9.3
+		 */
+		public static const MEDIUM:int = 2;
+		
+		/**
+		 *  Constant that specifies the lowest cursor priority when passed
+		 *  as the <code>priority</code> argument to <code>setCursor()</code>.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 9
+		 *  @playerversion AIR 1.1
+		 *  @productversion Royale 0.9.3
+		 */
+		public static const LOW:int = 3;
+		
+		
+	}
 	
-	
-}
-
 }
diff --git a/frameworks/projects/SparkRoyale/src/main/resources/spark-royale-manifest.xml b/frameworks/projects/SparkRoyale/src/main/resources/spark-royale-manifest.xml
index 19d3e99b2..a25d47365 100644
--- a/frameworks/projects/SparkRoyale/src/main/resources/spark-royale-manifest.xml
+++ b/frameworks/projects/SparkRoyale/src/main/resources/spark-royale-manifest.xml
@@ -106,5 +106,8 @@
 	<component id="Parallel" class="mx.effects.Parallel" lookupOnly="true"/>
 	<component id="BasicLayout" class="spark.layouts.BasicLayout"/>
 	<component id="FormLayout" class="spark.layouts.FormLayout"/>
-    
+	<component id="TabBar" class="spark.components.TabBar"/>
+	<component id="ButtonBar" class="spark.components.ButtonBar"/>
+	<component id="SkinnablePopUpContainer" class="spark.components.SkinnablePopUpContainer"/>
+	
 </componentPackage>
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/SparkRoyaleClasses.as b/frameworks/projects/SparkRoyale/src/main/royale/SparkRoyaleClasses.as
index 46205f92a..3d3c4cd0e 100644
--- a/frameworks/projects/SparkRoyale/src/main/royale/SparkRoyaleClasses.as
+++ b/frameworks/projects/SparkRoyale/src/main/royale/SparkRoyaleClasses.as
@@ -71,6 +71,8 @@ internal class SparkRoyaleClasses
 	import spark.components.FormItem; FormItem;
 	import spark.core.IDisplayText; IDisplayText;
 	import spark.events.PopUpEvent; PopUpEvent;
+	import spark.modules.Module; Module;
+	import spark.components.SkinnablePopUpContainer; SkinnablePopUpContainer;
 	
 }
 
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/components/ButtonBar.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/ButtonBar.as
new file mode 100644
index 000000000..d3be32fb9
--- /dev/null
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/ButtonBar.as
@@ -0,0 +1,296 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package spark.components
+{ 
+	/*
+	import flash.display.InteractiveObject;
+	import flash.events.Event;
+	import flash.events.EventPhase;
+	import flash.events.IEventDispatcher;
+	import flash.events.FocusEvent;
+	import flash.events.KeyboardEvent;
+	import flash.events.MouseEvent;
+	import flash.ui.Keyboard;
+	*/
+	
+	import org.apache.royale.events.Event;
+	
+	import spark.components.supportClasses.ButtonBarBase;
+	import spark.events.IndexChangeEvent;
+	// import spark.events.RendererExistenceEvent;
+	
+	import mx.collections.IList;
+	import mx.core.EventPriority;
+	import mx.core.IFactory;
+	// import mx.core.ISelectableList;
+	import mx.core.IVisualElement;
+	import mx.core.mx_internal;
+	import mx.events.CollectionEvent;
+	import mx.events.CollectionEventKind;
+	import mx.events.FlexEvent;
+	import mx.managers.IFocusManagerComponent;
+	
+	use namespace mx_internal;  //ListBase and List share selection properties that are mx_internal
+	
+	// [IconFile("ButtonBar.png")]
+	
+	/**
+	 *  The ButtonBar control defines a horizontal group of 
+	 *  logically related buttons with a common look and navigation.
+	 *
+	 *  <p>The typical use for a button bar is for grouping
+	 *  a set of related buttons together, which gives them a common look
+	 *  and navigation, and handling the logic for the <code>change</code> event
+	 *  in a single place. </p>
+	 *
+	 *  <p>The ButtonBar control creates Button controls based on the value of 
+	 *  its <code>dataProvider</code> property. 
+	 *  Use methods such as <code>addItem()</code> and <code>removeItem()</code> 
+	 *  to manipulate the <code>dataProvider</code> property to add and remove data items. 
+	 *  The ButtonBar control automatically adds or removes the necessary children based on 
+	 *  changes to the <code>dataProvider</code> property.</p>
+	 *
+	 *  <p>To use this component in a list-based component, such as a List or DataGrid, 
+	 *  create an item renderer.
+	 *  For information about creating an item renderer, see 
+	 *  <a href="http://help.adobe.com/en_US/flex/using/WS4bebcd66a74275c3-fc6548e124e49b51c4-8000.html">
+	 *  Custom Spark item renderers</a>. </p>
+	 *
+	 *  <p>For non-mobile projects, you can use the ButtonBar control to set the
+	 *  active child of a ViewStack container, as the following example shows:</p>
+	 *
+	 *  <p><b>Note: </b>The Spark list-based controls (the Spark ListBase class and its subclasses
+	 *  such as ButtonBar, ComboBox, DropDownList, List, and TabBar) do not support the BasicLayout class
+	 *  as the value of the <code>layout</code> property. 
+	 *  Do not use BasicLayout with the Spark list-based controls.</p>
+	 *
+	 *  <pre>
+	 *  &lt;s:ButtonBar dataProvider="{myViewStack}" requireSelection="true" /&gt; 
+	 *  
+	 *  &lt;mx:ViewStack id="myViewStack" 
+	 *      borderStyle="solid"&gt; 
+	 *  
+	 *      &lt;s:NavigatorContent id="search" label="Search"&gt; 
+	 *          &lt;s:Label text="Search Screen"/&gt; 
+	 *          &lt;/s:NavigatorContent&gt; 
+	 *  
+	 *      &lt;s:NavigatorContent id="custInfo" label="Customer Info"&gt; 
+	 *          &lt;s:Label text="Customer Info"/&gt; 
+	 *          &lt;/s:NavigatorContent&gt; 
+	 *  
+	 *      &lt;s:NavigatorContent id="accountInfo" label="Account Info"&gt; 
+	 *          &lt;s:Label text="Account Info"/&gt; 
+	 *          &lt;/s:NavigatorContent&gt; 
+	 *      &lt;/mx:ViewStack&gt; </pre>
+	 *  
+	 *  <p>The ButtonBar control has the following default characteristics:</p>
+	 *  <table class="innertable">
+	 *     <tr><th>Characteristic</th><th>Description</th></tr>
+	 *     <tr><td>Default size</td><td>Large enough to display all buttons</td></tr>
+	 *     <tr><td>Minimum size</td><td>0 pixels</td></tr>
+	 *     <tr><td>Maximum size</td><td>No limit</td></tr>
+	 *     <tr><td>Default skin class</td><td>spark.skins.spark.ButtonBarSkin</td></tr>
+	 *  </table>
+	 *  
+	 *  @mxml <p>The <code>&lt;s:ButtonBar&gt;</code> tag inherits all of the tag 
+	 *  attributes of its superclass and adds the following tag attributes:</p>
+	 *
+	 *  <pre>
+	 *  &lt;s:ButtonBar
+	 *
+	 *  /&gt;
+	 *  </pre>
+	 *
+	 *  @see mx.containers.ViewStack
+	 *  @see spark.components.ButtonBarButton
+	 *  @see spark.skins.spark.ButtonBarSkin
+	 *
+	 *  @includeExample examples/ButtonBarExample.mxml
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 1.5
+	 *  @productversion Flex 4
+	 */
+	public class ButtonBar extends ButtonBarBase // implements IFocusManagerComponent 
+	{
+		// include "../core/Version.as";
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Constructor
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Constructor.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4
+		 */
+		public function ButtonBar()
+		{
+			super();
+			
+			// itemRendererFunction = defaultButtonBarItemRendererFunction;
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Properties
+		//
+		//--------------------------------------------------------------------------
+		
+		//----------------------------------
+		//  firstButton
+		//---------------------------------- 
+		
+		[SkinPart(required="false", type="mx.core.IVisualElement")]
+		
+		/**
+		 * A skin part that defines the first button.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4
+		 */
+		public var firstButton:IFactory;
+		
+		//----------------------------------
+		//  lastButton
+		//---------------------------------- 
+		
+		[SkinPart(required="false", type="mx.core.IVisualElement")]
+		
+		/**
+		 * A skin part that defines the last button.
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4
+		 */
+		public var lastButton:IFactory;
+		
+		//----------------------------------
+		//  middleButton
+		//---------------------------------- 
+		
+		[SkinPart(required="true", type="mx.core.IVisualElement")]
+		
+		/**
+		 * A skin part that defines the middle button(s).
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4
+		 */
+		public var middleButton:IFactory;
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Overridden Properties
+		//
+		//--------------------------------------------------------------------------
+		
+		//----------------------------------
+		//  dataProvider
+		//----------------------------------
+		
+		[Inspectable(category="Data")]
+		
+		/**
+		 *  @private
+		 */    
+		/*override public function set dataProvider(value:IList):void
+		{
+			if (dataProvider)
+				dataProvider.removeEventListener(CollectionEvent.COLLECTION_CHANGE, resetCollectionChangeHandler);
+			
+			// not really a default handler, we just want it to run after the datagroup
+			if (value)
+				value.addEventListener(CollectionEvent.COLLECTION_CHANGE, resetCollectionChangeHandler, false, EventPriority.DEFAULT_HANDLER, true);
+			
+			super.dataProvider = value;
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		private function resetCollectionChangeHandler(event:Event):void
+		{
+			/*if (event is CollectionEvent)
+			{
+				var ce:CollectionEvent = CollectionEvent(event);
+				
+				if (ce.kind == CollectionEventKind.ADD || 
+					ce.kind == CollectionEventKind.REMOVE)
+				{
+					// force reset here so first/middle/last skins
+					// get reassigned
+					if (dataGroup)
+					{
+						dataGroup.layout.useVirtualLayout = true;
+						dataGroup.layout.useVirtualLayout = false;
+					}
+				}
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 *  button bar always keeps something under the caret so don't let it
+		 *  become -1
+		 */
+		/*override mx_internal function setCurrentCaretIndex(value:Number):void
+		{
+			if (value == -1)
+				return;
+			
+			super.setCurrentCaretIndex(value);
+		}*/
+		
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Private Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		private function defaultButtonBarItemRendererFunction(data:Object):IFactory
+		{
+			/*var i:int = dataProvider.getItemIndex(data);
+			if (i == 0)
+				return firstButton ? firstButton : middleButton;
+			
+			var n:int = dataProvider.length - 1;
+			if (i == n)
+				return lastButton ? lastButton : middleButton;
+			*/
+			return middleButton;
+		}
+	}
+	
+}
+
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/components/SkinnablePopUpContainer.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/SkinnablePopUpContainer.as
new file mode 100644
index 000000000..fe4b9b139
--- /dev/null
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/SkinnablePopUpContainer.as
@@ -0,0 +1,1462 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package spark.components
+{
+	/*
+	import flash.display.DisplayObject;
+	import flash.display.DisplayObjectContainer;
+	import flash.display.Stage;
+	import flash.events.Event;
+	import flash.events.MouseEvent;
+	import flash.events.SoftKeyboardEvent;
+	import flash.events.SoftKeyboardTrigger;
+	import flash.events.TimerEvent;
+	import flash.geom.Rectangle;
+	import flash.utils.Timer;
+	*/
+	
+	import mx.core.EventPriority;
+	import mx.core.FlexGlobals;
+	import mx.core.FlexVersion;
+	import mx.core.mx_internal;
+		
+	import mx.effects.Parallel;
+	import mx.events.EffectEvent;
+	import mx.events.FlexEvent;
+	import mx.events.SandboxMouseEvent;
+	import mx.managers.PopUpManager;
+	import mx.managers.SystemManager;
+	// import mx.styles.StyleProtoChain;
+	
+	// import mx.effects.IEffect;
+	// import spark.effects.Move;
+	// import spark.effects.Resize;
+
+	import org.apache.royale.events.Event;
+	import org.apache.royale.events.MouseEvent;
+	import org.apache.royale.utils.Timer;
+	
+	import org.apache.royale.effects.IEffect;
+	import org.apache.royale.effects.Move;
+	import org.apache.royale.effects.Resize;
+	
+	import mx.core.UIComponent;
+
+	// import spark.effects.animation.Animation;
+	// import spark.effects.easing.IEaser;
+	// import spark.effects.easing.Power;
+	import spark.events.PopUpEvent;
+	
+	use namespace mx_internal;
+	
+	//--------------------------------------
+	//  Events
+	//--------------------------------------
+	
+	/**
+	 *  Dispatched by the container when it's opened and ready for user interaction.
+	 *
+	 *  <p>This event is dispatched when the container switches from the
+	 *  <code>closed</code> to <code>normal</code> skin state and the transition
+	 *  to that state completes.</p>
+	 *
+	 *  <p>Note: As of Flex 4.6, SkinnablePopUp container inherits its styles
+	 *  from the stage and not its owner.</p>
+	 *
+	 *  @eventType spark.events.PopUpEvent.OPEN
+	 *
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 2.5
+	 *  @productversion Flex 4.5
+	 */
+	[Event(name="open", type="spark.events.PopUpEvent")]
+	
+	/**
+	 *  Dispatched by the container when it's closed.
+	 *
+	 *  <p>This event is dispatched when the container switches from the
+	 *  <code>normal</code> to <code>closed</code> skin state and
+	 *  the transition to that state completes.</p>
+	 *
+	 *  <p>The event provides a mechanism to pass commit information from
+	 *  the container to an event listener.
+	 *  One typical usage scenario is building a multiple-choice dialog with a
+	 *  cancel button.
+	 *  When a valid option is selected, you close the pop up
+	 *  with a call to the <code>close()</code> method, passing
+	 *  <code>true</code> to the <code>commit</code> parameter and optionally passing in
+	 *  any relevant data.
+	 *  When the SkinnablePopUpContainer has completed closing,
+	 *  it dispatches this event.
+	 *  Then, in the event listener, you can check the <code>commit</code>
+	 *  property and perform the appropriate action.  </p>
+	 *
+	 *  @eventType spark.events.PopUpEvent.CLOSE
+	 *
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 2.5
+	 *  @productversion Flex 4.5
+	 */
+	[Event(name="close", type="spark.events.PopUpEvent")]
+	
+	//--------------------------------------
+	//  Styles
+	//--------------------------------------
+	
+	/**
+	 *  Duration of the soft keyboard move and resize effect in milliseconds.
+	 *
+	 *  @default 150
+	 *
+	 *  @langversion 3.0
+	 *  @playerversion Flash 11
+	 *  @playerversion AIR 3.1
+	 *  @productversion Flex 4.6
+	 */
+	[Style(name="softKeyboardEffectDuration", type="Number", format="Time", inherit="no", minValue="0.0")]
+	
+	//--------------------------------------
+	//  States
+	//--------------------------------------
+	
+	/**
+	 *  The closed state.
+	 *
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 2.5
+	 *  @productversion Flex 4.5
+	 */
+	[SkinState("closed")]
+	
+	/**
+	 *  The SkinnablePopUpContainer class is a SkinnableContainer that functions as a pop-up.
+	 *  One typical use for a SkinnablePopUpContainer container is to open a simple window
+	 *  in an application, such as an alert window, to indicate that the user must perform some action.
+	 *
+	 *  <p>You do not create a SkinnablePopUpContainer container as part of the normal layout
+	 *  of its parent container.
+	 *  Instead, it appears as a pop-up window on top of its parent.
+	 *  Therefore, you do not create it directly in the MXML code of your application.</p>
+	 *
+	 *  <p>Instead, you create is as an MXML component, often in a separate MXML file.
+	 *  To show the component create an instance of the MXML component, and
+	 *  then call the <code>open()</code> method.
+	 *  You can also set the size and position of the component when you open it.</p>
+	 *
+	 *  <p>To close the component, call the <code>close()</code> method.
+	 *  If the pop-up needs to return data to a handler, you can add an event listener for
+	 *  the <code>PopUp.CLOSE</code> event, and specify the returned data in
+	 *  the <code>close()</code> method.</p>
+	 *
+	 *  <p>The SkinnablePopUpContainer is initially in its <code>closed</code> skin state.
+	 *  When it opens, it adds itself as a pop-up to the PopUpManager,
+	 *  and transition to the <code>normal</code> skin state.
+	 *  To define open and close animations, use a custom skin with transitions between
+	 *  the <code>closed</code> and <code>normal</code> skin states.</p>
+	 *
+	 *  <p>The SkinnablePopUpContainer container has the following default characteristics:</p>
+	 *     <table class="innertable">
+	 *     <tr><th>Characteristic</th><th>Description</th></tr>
+	 *     <tr><td>Default size</td><td>Large enough to display its children</td></tr>
+	 *     <tr><td>Minimum size</td><td>0 pixels</td></tr>
+	 *     <tr><td>Maximum size</td><td>10000 pixels wide and 10000 pixels high</td></tr>
+	 *     <tr><td>Default skin class</td><td>spark.skins.spark.SkinnablePopUpContainerSkin</td></tr>
+	 *     </table>
+	 *
+	 *  @mxml <p>The <code>&lt;s:SkinnablePopUpContainer&gt;</code> tag inherits all of the tag
+	 *  attributes of its superclass and adds the following tag attributes:</p>
+	 *
+	 *  <pre>
+	 *  &lt;s:SkinnablePopUpContainer
+	 *    <strong>Events</strong>
+	 *    close="<i>No default</i>"
+	 *    open="<i>No default</i>"
+	 *  /&gt;
+	 *  </pre>
+	 *
+	 *  @see spark.skins.spark.SkinnablePopUpContainerSkin
+	 *
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 2.5
+	 *  @productversion Flex 4.5
+	 */
+	public class SkinnablePopUpContainer extends SkinnableContainer
+	{
+		//--------------------------------------------------------------------------
+		//
+		//  Constructor
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Constructor.
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 2.5
+		 *  @productversion Flex 4.5
+		 */
+		public function SkinnablePopUpContainer()
+		{
+			super();
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Variables
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Storage for the close event while waiting for the close transition to
+		 *  complete before dispatching it.
+		 *
+		 *  @private
+		 */
+		private var closeEvent:PopUpEvent;
+		
+		/**
+		 *  Track whether the container is added to the PopUpManager.
+		 *
+		 *  @private
+		 */
+		private var addedToPopUpManager:Boolean = false;
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Soft Keyboard Effect Variables
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  The current soft keyboard effect instance. This field is only set in
+		 *  cases where the position and size are not snapped during (a) initial
+		 *  activation and (b) deactivation.
+		 */
+		private var softKeyboardEffect:IEffect;
+		
+		/**
+		 *  @private
+		 *  Original pop-up y-position.
+		 */
+		private var softKeyboardEffectCachedYPosition:Number;
+		
+		/**
+		 *  @private
+		 *  Indicates a soft keyboard event was received but the effect is delayed
+		 *  while waiting for a mouseDown and mouseUp event sequence.
+		 */
+		private var softKeyboardEffectPendingEventType:String = null;
+		
+		/**
+		 *  @private
+		 *  Number of milliseconds to wait for a mouseDown and mouseUp event
+		 *  sequence before playing the deactivate effect.
+		 */
+		mx_internal var softKeyboardEffectPendingEffectDelay:Number = 100;
+		
+		/**
+		 *  @private
+		 *  Timer used for awaiting a mouseDown event after a pending soft keyboard
+		 *  effect.
+		 */
+		private var softKeyboardEffectPendingEventTimer:Timer;
+		
+		/**
+		 *  @private
+		 *  Flag when orientationChanging is dispatched and orientationChange has
+		 *  not been received.
+		 */
+		private var softKeyboardEffectOrientationChanging:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Flag when orientation change handlers are installed to suppress
+		 *  excess soft keyboard effects during orientation change on iOS.
+		 */
+		private var softKeyboardEffectOrientationHandlerAdded:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Flag when mouse and orientation listeners are installed before
+		 *  the soft keyboard activate effect is played.
+		 */
+		private var softKeyboardStateChangeListenersInstalled:Boolean;
+		
+		/**
+		 *  @private
+		 *  Flag when resize listers are installed after ACTIVATE and uninstalled
+		 *  just before DEACTIVATE.
+		 */
+		private var resizeListenerInstalled:Boolean = false;
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Properties
+		//
+		//--------------------------------------------------------------------------
+		
+		//----------------------------------
+		//  isOpen
+		//----------------------------------
+		
+		/**
+		 *  Storage for the isOpen property.
+		 *
+		 *  @private
+		 */
+		private var _isOpen:Boolean = false;
+		
+		[Inspectable(category="General", defaultValue="false")]
+		
+		/**
+		 *  Contains <code>true</code> when the container is open and is currently showing as a pop-up.
+		 *
+		 *  @see #open
+		 *  @see #close
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 2.5
+		 *  @productversion Flex 4.5
+		 */
+		public function get isOpen():Boolean
+		{
+			return _isOpen;
+		}
+		
+		/**
+		 *  Updates the isOpen flag to be reflected in the skin state
+		 *  without actually popping up the container through the PopUpManager.
+		 *
+		 *  @private
+		 */
+		mx_internal function setIsOpen(value:Boolean):void
+		{
+			// NOTE: DesignView relies on this API, consult tooling before making changes.
+			_isOpen = value;
+			invalidateSkinState();
+		}
+		
+		//----------------------------------
+		//  resizeForSoftKeyboard
+		//----------------------------------
+		
+		private var _resizeForSoftKeyboard:Boolean = true;
+		
+		/**
+		 *  Enables resizing the pop-up when the soft keyboard
+		 *  on a mobile device is active.
+		 *
+		 *  @default true
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion AIR 3
+		 *  @productversion Flex 4.6
+		 */
+		public function get resizeForSoftKeyboard():Boolean
+		{
+			return _resizeForSoftKeyboard;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set resizeForSoftKeyboard(value:Boolean):void
+		{
+			if (_resizeForSoftKeyboard == value)
+				return;
+			
+			_resizeForSoftKeyboard = value;
+		}
+		
+		//----------------------------------
+		//  moveForSoftKeyboard
+		//----------------------------------
+		
+		private var _moveForSoftKeyboard:Boolean = true;
+		
+		/**
+		 *  Enables moving the pop-up when the soft keyboard
+		 *  on a mobile device is active.
+		 *
+		 *  @default true
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion AIR 3
+		 *  @productversion Flex 4.6
+		 */
+		public function get moveForSoftKeyboard():Boolean
+		{
+			return _moveForSoftKeyboard;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set moveForSoftKeyboard(value:Boolean):void
+		{
+			if (_moveForSoftKeyboard == value)
+				return;
+			
+			_moveForSoftKeyboard = value;
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Opens the container as a pop-up, and switches the skin state from
+		 *  <code>closed</code> to <code>normal</code>.
+		 *  After and transitions finish playing, it dispatches  the
+		 *  <code>FlexEvent.OPEN</code> event.
+		 *
+		 *  @param owner The owner of the container.
+		 *  The popup appears over this component. The owner must not be descendant
+		 *  of this container.
+		 *
+		 *  @param modal Whether the container should be modal.
+		 *  A modal container takes all keyboard and mouse input until it is closed.
+		 *  A nonmodal container allows other components to accept input while the pop-up window is open.
+		 *
+		 *  @see #close
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 2.5
+		 *  @productversion Flex 4.5
+		 */
+		public function open(owner:UIComponent /*DisplayObjectContainer*/, modal:Boolean = false):void
+		{
+			if (isOpen)
+				return;
+			
+			closeEvent = null; // Clear any pending close event
+			this.owner = owner;
+			
+			// We track whether we've been added to the PopUpManager to handle the
+			// scenario of state transition interrupton. For example we may be playing
+			// a close transition and be interrupted with a call to open() in which
+			// case we wouldn't have removed the container from the PopUpManager since
+			// the close transition never reached its end.
+			if (!addedToPopUpManager)
+			{
+				addedToPopUpManager = true;
+				
+				// This will create the skin and attach it
+				PopUpManager.addPopUp(this, owner, modal);
+				
+				updatePopUpPosition();
+			}
+			
+			// Change state *after* we pop up, as the skin needs to go be in the initial "closed"
+			// state while being created above in order for transitions to detect state change and play.
+			_isOpen = true;
+			invalidateSkinState();
+			if (skin)
+				skin.addEventListener(FlexEvent.STATE_CHANGE_COMPLETE, stateChangeComplete_handler);
+			else
+				stateChangeComplete_handler(null); // Call directly
+		}
+		
+		/**
+		 *  Positions the pop-up after the pop-up is added to PopUpManager but
+		 *  before any state transitions occur. The base implementation of open()
+		 *  calls updatePopUpPosition() immediately after the pop-up is added.
+		 *
+		 *  This method may also be called at any time to update the pop-up's
+		 *  position. Pop-ups that are positioned relative to their owner should
+		 *  call this method after position or size changes occur on the owner or
+		 *  it's ancestors.
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion AIR 3
+		 *  @productversion Flex 4.6
+		 */
+		public function updatePopUpPosition():void
+		{
+			// subclasses will implement custom positioning
+			// e.g. PopUpManager.centerPopUp()
+		}
+		
+		/**
+		 *  Changes the current skin state to <code>closed</code>, waits until any state transitions
+		 *  finish playing, dispatches a <code>PopUpEvent.CLOSE</code> event,
+		 *  and then removes the container from the PopUpManager.
+		 *
+		 *  <p>Use the <code>close()</code> method of the SkinnablePopUpContainer container
+		 *  to pass data back to the main application from the pop up.
+		 *  One typical usage scenario is building a dialog with a cancel button.
+		 *  When a valid option is selected in the dialog box, you close the dialog
+		 *  with a call to the <code>close()</code> method, passing
+		 *  <code>true</code> to the <code>commit</code> parameter and optionally passing
+		 *  any relevant data.
+		 *  When the SkinnablePopUpContainer has completed closing,
+		 *  it dispatch the <code>close</code> event.
+		 *  In the event listener for the <code>close</code> event, you can check
+		 *  the <code>commit</code> parameter and perform the appropriate actions.  </p>
+		 *
+		 *  @param commit Specifies if the return data should be committed by the application.
+		 *  The value of this argument is written to the <code>commit</code> property of
+		 *  the <code>PopUpEvent</code> event object.
+		 *
+		 *  @param data Specifies any data returned to the application.
+		 *  The value of this argument is written to the <code>data</code> property of
+		 *  the <code>PopUpEvent</code> event object.
+		 *
+		 *  @see #open
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 2.5
+		 *  @productversion Flex 4.5
+		 */
+		public function close(commit:Boolean = false, data:* = undefined):void
+		{
+			if (!isOpen)
+				return;
+			
+			// We will dispatch the event later, when the close transition is complete.
+			closeEvent = new PopUpEvent(PopUpEvent.CLOSE, false, false, commit, data);
+			
+			// Change state
+			_isOpen = false;
+			invalidateSkinState();
+			
+			if (skin)
+				skin.addEventListener(FlexEvent.STATE_CHANGE_COMPLETE, stateChangeComplete_handler);
+			else
+				stateChangeComplete_handler(null); // Call directly
+		}
+		
+		/**
+		 *  Called by the soft keyboard <code>activate</code> and <code>deactive</code> event handlers,
+		 *  this method is responsible for creating the Spark effect played on the pop-up.
+		 *
+		 *  This method may be overridden by subclasses. By default, it
+		 *  creates a parellel move and resize effect on the pop-up.
+		 *
+		 *  @param yTo The new y-coordinate of the pop-up.
+		 *
+		 *  @param height The new height of the pop-up.
+		 *
+		 *  @return An IEffect instance serving as the move and/or resize transition
+		 *  for the pop-up. This effect is played after the soft keyboard is
+		 *  activated or deactivated.
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion AIR 3
+		 *  @productversion Flex 4.6
+		 */
+		protected function createSoftKeyboardEffect(yTo:Number, heightTo:Number):IEffect
+		{/*
+			var move:Move;
+			var resize:Resize;
+			var easer:IEaser = new Power(0, 5);
+			
+			if (yTo != this.y)
+			{
+				move = new Move();
+				move.target = this;
+				move.yTo = yTo;
+				move.disableLayout = true;
+				move.easer = easer;
+			}
+			
+			if (heightTo != this.height)
+			{
+				resize = new Resize();
+				resize.target = this;
+				resize.heightTo = heightTo;
+				resize.disableLayout = true;
+				resize.easer = easer;
+			}
+			
+			if (move && resize)
+			{
+				var parallel:Parallel = new Parallel();
+				parallel.addChild(move);
+				parallel.addChild(resize);
+				
+				return parallel;
+			}
+			else if (move || resize)
+			{
+				return (move) ? move : resize;
+			}*/
+			
+			return null;
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  mx_internal properties
+		//
+		//--------------------------------------------------------------------------
+		
+		//----------------------------------------
+		//  softKeyboardEffectCachedExplicitHeight
+		//----------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		private var _softKeyboardEffectExplicitHeightFlag:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Flag when explicitHeight is set when the soft keyboard effect is
+		 *  active. Use this to distinguish explicitHeight changes due to the
+		 *  resizeForSoftKeyboard setting. When true, we prevent the original
+		 *  cached height from being modified.
+		 */
+		mx_internal function get softKeyboardEffectExplicitHeightFlag():Boolean
+		{
+			return _softKeyboardEffectExplicitHeightFlag;
+		}
+		
+		private function setSoftKeyboardEffectExplicitHeightFlag(value:Boolean):void
+		{
+			_softKeyboardEffectExplicitHeightFlag = value;
+		}
+		
+		//----------------------------------------
+		//  softKeyboardEffectCachedExplicitWidth
+		//----------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		private var _softKeyboardEffectExplicitWidthFlag:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Flag when explicitWidth is set when the soft keyboard effect is
+		 *  active. Use this to distinguish explicitWidth changes due to the
+		 *  resizeForSoftKeyboard setting.
+		 */
+		mx_internal function get softKeyboardEffectExplicitWidthFlag():Boolean
+		{
+			return _softKeyboardEffectExplicitWidthFlag;
+		}
+		
+		private function setSoftKeyboardEffectExplicitWidthFlag(value:Boolean):void
+		{
+			_softKeyboardEffectExplicitWidthFlag = value;
+		}
+		
+		//----------------------------------
+		//  softKeyboardEffectCachedHeight
+		//----------------------------------
+		
+		private var _softKeyboardEffectCachedHeight:Number;
+		
+		/**
+		 *  @private
+		 *  The original pop-up height to restore to when the soft keyboard is
+		 *  deactivated. If an explicitHeight was defined at activation, use it.
+		 *  If not, then use explicitMaxHeight or measuredHeight.
+		 */
+		mx_internal function get softKeyboardEffectCachedHeight():Number
+		{
+			var heightTo:Number = _softKeyboardEffectCachedHeight;
+			
+			if (!softKeyboardEffectExplicitHeightFlag)
+			{
+				if (!isNaN(explicitMaxHeight) && (measuredHeight > explicitMaxHeight))
+					heightTo = explicitMaxHeight;
+				else
+					heightTo = measuredHeight;
+			}
+			
+			return heightTo;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function setSoftKeyboardEffectCachedHeight(value:Number):void
+		{
+			// Only allow changes to the cached height if it was not set explicitly
+			// prior to and/or during the soft keyboard effect.
+			if (!softKeyboardEffectExplicitHeightFlag)
+				_softKeyboardEffectCachedHeight = value;
+		}
+		
+		//----------------------------------
+		//  isSoftKeyboardEffectActive
+		//----------------------------------
+		
+		private var _isSoftKeyboardEffectActive:Boolean;
+		
+		/**
+		 *  @private
+		 *  Returns true if the soft keyboard is active and the pop-up is moved
+		 *  and/or resized.
+		 */
+		mx_internal function get isSoftKeyboardEffectActive():Boolean
+		{
+			return _isSoftKeyboardEffectActive;
+		}
+		
+		//----------------------------------
+		//  marginTop
+		//----------------------------------
+		
+		private var _marginTop:Number = 0;
+		
+		/**
+		 *  @private
+		 *  Defines a margin at the top of the screen where the pop-up cannot be
+		 *  resized or moved to.
+		 */
+		mx_internal function get softKeyboardEffectMarginTop():Number
+		{
+			return _marginTop;
+		}
+		
+		/**
+		 *  @private
+		 */
+		mx_internal function set softKeyboardEffectMarginTop(value:Number):void
+		{
+			_marginTop = value;
+		}
+		
+		//----------------------------------
+		//  marginBottom
+		//----------------------------------
+		
+		private var _marginBottom:Number = 0;
+		
+		/**
+		 *  @private
+		 *  Defines a margin at the bottom of the screen where the pop-up cannot be
+		 *  resized or moved to.
+		 */
+		mx_internal function get softKeyboardEffectMarginBottom():Number
+		{
+			return _marginBottom;
+		}
+		
+		/**
+		 *  @private
+		 */
+		mx_internal function set softKeyboardEffectMarginBottom(value:Number):void
+		{
+			_marginBottom = value;
+		}
+		
+		//----------------------------------
+		//  isMouseDown
+		//----------------------------------
+		
+		private var _isMouseDown:Boolean = false;
+		
+		/**
+		 *  @private
+		 */
+		private function get isMouseDown():Boolean
+		{
+			return _isMouseDown;
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function set isMouseDown(value:Boolean):void
+		{
+			_isMouseDown = value;
+			
+			// Attempt to play a pending effect
+			playPendingEffect(true);
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Overridden Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Force callout inheritance chain to start at the style root.
+		 */
+		/*override mx_internal function initProtoChain():void
+		{
+			// Maintain backwards compatibility of popup style inheritance
+			if (FlexVersion.compatibilityVersion < FlexVersion.VERSION_4_6)
+				super.initProtoChain();
+			else
+				StyleProtoChain.initProtoChain(this, false);
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		override protected function getCurrentSkinState():String
+		{
+			// The states are:
+			// "normal"
+			// "disabled"
+			// "closed"
+			
+			var state:String = super.getCurrentSkinState();
+			if (!isOpen)
+				return state == "normal" ? "closed" : state;
+			return state;
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Event handlers
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Play the soft keyboard effect.
+		 */
+		private function startEffect(event:Event):void
+		{/*
+			removeEventListener(Event.ENTER_FRAME, startEffect);
+			
+			// Abort the effect if the pop-up is closed or closing. The state 
+			// transition handler will restore the original size of the pop-up.
+			if (!isOpen || !softKeyboardEffect)
+				return;
+			
+			// Clear the cached positions when the deactivate effect is complete.
+			softKeyboardEffect.addEventListener(EffectEvent.EFFECT_END, softKeyboardEffectCleanup);
+			softKeyboardEffect.addEventListener(EffectEvent.EFFECT_STOP, softKeyboardEffectCleanup);
+			
+			// Install mouse delay and orientation change listeners now.
+			// explicitHeight listener is installed after the effect completes.
+			if (isSoftKeyboardEffectActive)
+				installSoftKeyboardStateChangeListeners();
+			
+			// Force the master clock of the animation engine to update its
+			// current time so that the overhead of creating the effect is not
+			// included in our animation interpolation. See SDK-27793
+			Animation.pulse();
+			softKeyboardEffect.play();*/
+		}
+		
+		/**
+		 *  @private
+		 *
+		 *  Called when we have completed transitioning to opened/closed state.
+		 */
+		private function stateChangeComplete_handler(event:Event):void
+		{/*
+			// We get called directly with null if there's no skin to listen to.
+			if (event)
+				event.target.removeEventListener(FlexEvent.STATE_CHANGE_COMPLETE, stateChangeComplete_handler);
+			
+			// Check for soft keyboard support
+			var topLevelApp:Application = FlexGlobals.topLevelApplication as Application;
+			var softKeyboardEffectEnabled:Boolean = (topLevelApp && Application.softKeyboardBehavior == "none");
+			var smStage:Stage = systemManager.stage;
+			
+			if (isOpen)
+			{
+				dispatchEvent(new PopUpEvent(PopUpEvent.OPEN, false, false));
+				
+				if (softKeyboardEffectEnabled)
+				{
+					if (smStage)
+					{
+						// Install soft keyboard event handling on the stage
+						smStage.addEventListener(SoftKeyboardEvent.SOFT_KEYBOARD_ACTIVATE,
+							stage_softKeyboardActivateHandler, true, EventPriority.DEFAULT, true);
+						smStage.addEventListener(SoftKeyboardEvent.SOFT_KEYBOARD_DEACTIVATE,
+							stage_softKeyboardDeactivateHandler, true, EventPriority.DEFAULT, true);
+						
+						// Use lower priority listener to allow subclasses to act 
+						// on the resize event before the soft keyboard effect does.
+						systemManager.addEventListener(Event.RESIZE, systemManager_resizeHandler, false, EventPriority.EFFECT);
+						
+						updateSoftKeyboardEffect(true);
+					}
+				}
+			}
+			else
+			{
+				// Dispatch the close event before removing from the PopUpManager.
+				dispatchEvent(closeEvent);
+				closeEvent = null;
+				
+				if (softKeyboardEffectEnabled && smStage)
+				{
+					// Uninstall soft keyboard event handling
+					smStage.removeEventListener(SoftKeyboardEvent.SOFT_KEYBOARD_ACTIVATE,
+						stage_softKeyboardActivateHandler, true);
+					smStage.removeEventListener(SoftKeyboardEvent.SOFT_KEYBOARD_DEACTIVATE,
+						stage_softKeyboardDeactivateHandler, true);
+					systemManager.removeEventListener(Event.RESIZE, systemManager_resizeHandler);
+				}
+				
+				// We just finished closing, remove from the PopUpManager.
+				PopUpManager.removePopUp(this);
+				addedToPopUpManager = false;
+				owner = null;
+				
+				// Position and size may be invalid if the close transition
+				// completes before (a) deactivate is fired or (b) a pending
+				// soft keyboard change is still queued. Update immediately.
+				updateSoftKeyboardEffect(true);
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 */
+		/*private function stage_softKeyboardActivateHandler(event:SoftKeyboardEvent=null):void
+		{
+			var isFirstActivate:Boolean = false;
+			
+			// Reset state
+			softKeyboardEffectPendingEventType = null;
+			
+			// Save the original y-position and height if this is the first
+			// ACTIVATE event and an existing effect is not already in progress.
+			if (!isSoftKeyboardEffectActive && !softKeyboardEffect)
+				isFirstActivate = true;
+			
+			if (isFirstActivate)
+			{
+				// Play the activate effect with animation
+				updateSoftKeyboardEffect(false);
+			}
+			else
+			{
+				// Keyboard height has changed. However, the effect can be delayed if
+				// a mouseUp within the pop-up is pending. An additional activate can
+				// occur while the keyboard is open to reflect size changes due to auto
+				// correction or orientation changes.
+				
+				// As in the deactivate case, the move and resize effects should be
+				// delayed until the user can complete any mouse interaction. This
+				// allows the size and position of the pop-up to stay stable allowing
+				// events like a button press to complete normally.
+				
+				if (isMouseDown)
+					setPendingSoftKeyboardEvent(event);
+				else
+					updateSoftKeyboardEffect(true);
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*private function stage_softKeyboardDeactivateHandler(event:SoftKeyboardEvent=null):void
+		{
+			// If the effect is not active (no move or resize was needed), do 
+			// nothing. If we're in the middle of an orientation change, also do 
+			// nothing.
+			if (!isSoftKeyboardEffectActive || softKeyboardEffectOrientationChanging)
+				return;
+			
+			// Reset state
+			softKeyboardEffectPendingEventType = null;
+			
+			if (event.triggerType == SoftKeyboardTrigger.USER_TRIGGERED)
+			{
+				// userTriggered indicates they keyboard was closed explicitly (soft
+				// button on soft keyboard) or on Android, pressing the back button.
+				// Play the deactivate effect immediately.
+				updateSoftKeyboardEffect(false);
+			}
+			else // if (event.triggerType == SoftKeyboardTrigger.CONTENT_TRIGGERED)
+			{
+				// contentTriggered indicates focus was lost by tapping away from
+				// StageText or a programmatic call. Unfortunately, this
+				// distinction isn't entirely intuitive. We only care about delaying
+				// the deactivate effect when due to a mouse event. Delaying the
+				// effect allows the pop-up position and size to stay static until
+				// any mouse interaction is complete (e.g. button click).
+				// However, the softKeyboardDeactivate event is fired before
+				// the mouseDown event:
+				//   deactivate -> mouseDown -> mouseUp
+				
+				// The approach here is to assume that a mouseDown was the trigger
+				// for the softKeyboardDeactivate event. Continue to delay the
+				// deactivate effect until a mouseDown and mouseUp sequence is
+				// received. In the event that the deactivation was due to a
+				// programmatic call, we'll stop this process after a specified
+				// delay time.
+				
+				// If, in the future, the event order changes to either:
+				//   (a) mouseDown -> deactivate -> mouseUp
+				//   (b) mouseDown -> mouseUp -> deactivate
+				// this approach will still work for the button click use case.
+				// Sequence (b) would simply fire a normal button click and have
+				// the consequence of a delayed deactivate effect only.
+				setPendingSoftKeyboardEvent(event);
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  Disable soft keyboard deactivate when orientation is changing.
+		 */
+		private function stage_orientationChangingHandler(event:Event):void
+		{
+			softKeyboardEffectOrientationChanging = true;
+		}
+		
+		/**
+		 *  @private
+		 *  Re-enable soft keyboard deactivate effect when orietation change 
+		 *  completes.
+		 */
+		private function stage_orientationChangeHandler(event:Event):void
+		{
+			softKeyboardEffectOrientationChanging = false;
+		}
+		
+		/**
+		 *  @private
+		 *  Listens for mouse events while the soft keyboard effect is active.
+		 */
+		private function mouseHandler(event:MouseEvent):void
+		{
+			isMouseDown = (event.type == MouseEvent.MOUSE_DOWN);
+		}
+		
+		private function systemManager_mouseUpHandler(event:Event):void
+		{
+			isMouseDown = false;
+		}
+		
+		/**
+		 *  @private
+		 *  This function is only called when the pendingEffectTimer completed and no
+		 *  mouseDown and mouseUp sequence was fired.
+		 */
+		private function pendingEffectTimer_timerCompleteHandler(event:Event):void
+		{
+			playPendingEffect(false)
+		}
+		
+		/**
+		 *  @private
+		 *  Play the effect when (a) not triggered by a mouse event or
+		 *  (b) triggered by a mouseUp event
+		 */
+		private function playPendingEffect(isMouseEvent:Boolean):void
+		{/*
+			var isTimerRunning:Boolean = softKeyboardEffectPendingEventTimer && softKeyboardEffectPendingEventTimer.running;
+			
+			// Received a mouseDown event while the timer is still running. Stop
+			// the timer and wait for the next mouseUp.
+			var mouseDownDuringTimer:Boolean = isTimerRunning &&
+				(isMouseEvent && isMouseDown);
+			
+			// Cleanup the timer if we're (a) waiting for the next mouseUp or
+			// (b) this function was called for timerComplete
+			if (softKeyboardEffectPendingEventTimer && (mouseDownDuringTimer || !isMouseEvent))
+			{
+				softKeyboardEffectPendingEventTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, pendingEffectTimer_timerCompleteHandler);
+				softKeyboardEffectPendingEventTimer.stop();
+				softKeyboardEffectPendingEventTimer = null;
+				
+				// If we caught a mouse down during the timer, we wait for the next
+				// mouseUp event. There is no effect to play. If this isn't a mouse
+				// event and the timer completed, then fall through and play the
+				// pending effect.
+				if (mouseDownDuringTimer)
+					return;
+			}
+			
+			// Sanity check that a pendingEvent still exists and that the pop-up
+			// is currently open. If we timed out or if we got a mouseUp, then
+			// allow the pending effect to play.
+			var canPlayEffect:Boolean = softKeyboardEffectPendingEventType && isOpen &&
+				(!isMouseEvent || (isMouseEvent && !isMouseDown));
+			
+			// Effect isn't played when still waiting for a mouseUp
+			if (canPlayEffect)
+			{
+				// Clear pending state
+				var isActivate:Boolean = softKeyboardEffectPendingEventType == SoftKeyboardEvent.SOFT_KEYBOARD_ACTIVATE;
+				
+				// Snap the position only for pending activate events
+				updateSoftKeyboardEffect(isActivate);
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function softKeyboardEffectCleanup(event:EffectEvent):void
+		{
+			// Cleanup effect
+			softKeyboardEffect.removeEventListener(EffectEvent.EFFECT_END, softKeyboardEffectCleanup);
+			softKeyboardEffect.removeEventListener(EffectEvent.EFFECT_STOP, softKeyboardEffectCleanup);
+			softKeyboardEffect = null;
+			
+			if (isSoftKeyboardEffectActive)
+			{
+				installActiveResizeListener();
+			}
+			else
+			{
+				// Remove resize listeners
+				uninstallActiveResizeListener();
+				
+				// If the deactivate effect is complete, uninstall listeners for 
+				// mouse delay and orientation change listeners
+				uninstallSoftKeyboardStateChangeListeners();
+			}
+		}
+		
+		/**
+		 *  @private
+		 *  Set flags when explicit size changes are detected.
+		 */
+		private function resizeHandler(event:Event=null):void
+		{
+			setSoftKeyboardEffectExplicitWidthFlag(!isNaN(explicitWidth));
+			setSoftKeyboardEffectExplicitHeightFlag(!isNaN(explicitHeight));
+		}
+		
+		/**
+		 *  @private
+		 *  Update effect immediately after orientation change is
+		 *  followed by a system manager resize.
+		 */
+		private function systemManager_resizeHandler(event:Event):void
+		{
+			// Guard against extraneous resizing during orientation changing.
+			// See SDK-31860.
+			if (!softKeyboardEffectOrientationChanging)
+				updateSoftKeyboardEffect(true);
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Private Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Update the position and height for this pop-up for various state changes
+		 *  including: soft keyboard activation and deactivation, delayed soft
+		 *  keyboard events due to mouse and keyboard event sequence, and
+		 *  orientation change events.
+		 */
+		private function updateSoftKeyboardEffect(snapPosition:Boolean):void
+		{/*
+			// Stop the current effect
+			if (softKeyboardEffect && softKeyboardEffect.isPlaying)
+				softKeyboardEffect.stop();
+			
+			// Uninstall resize listeners during the effect. Listeners are 
+			// installed again after the effect is complete or immediately affter
+			// the size and position are snapped.
+			uninstallActiveResizeListener();
+			
+			var softKeyboardRect:Rectangle;
+			try {
+				softKeyboardRect = FlexGlobals.topLevelApplication.softKeyboardRect;
+			}
+			catch (error:Error) {
+				softKeyboardRect = null;
+			}
+			
+			var isKeyboardOpen:Boolean = isOpen && softKeyboardRect && (softKeyboardRect.height > 0);
+			
+			// Capture start values if not set
+			if (isNaN(softKeyboardEffectCachedYPosition))
+			{
+				if (isKeyboardOpen)
+				{
+					// Save original y-position and height
+					softKeyboardEffectCachedYPosition = this.y;
+					setSoftKeyboardEffectCachedHeight(this.height);
+					
+					// Initialize explicit size flags
+					resizeHandler();
+				}
+				else
+				{
+					// Keyboard is closed and we don't have any start values yet.
+					// Nothing to do.
+					return;
+				}
+			}
+			
+			var sandboxRoot:UIComponent = systemManager.getSandboxRoot();
+			
+			var yToLocal:Number = softKeyboardEffectCachedYPosition;
+			var heightToLocal:Number = softKeyboardEffectCachedHeight;
+			
+			// If the keyboard is active, check for overlap
+			if (isKeyboardOpen)
+			{
+				var scaleFactor:Number = 1;
+				
+				if (systemManager as SystemManager)
+					scaleFactor = SystemManager(systemManager).densityScale;
+				
+				// All calculations are done in stage coordinates and converted back to
+				// application coordinates when playing effects. Also note that
+				// softKeyboardRect is also in stage coordinates.
+				var popUpY:Number = yToLocal * scaleFactor;
+				var popUpHeight:Number = heightToLocal * scaleFactor;
+				var overlapGlobal:Number = (popUpY + popUpHeight) - softKeyboardRect.y;
+				
+				var yToGlobal:Number = popUpY;
+				var heightToGlobal:Number = popUpHeight;
+				
+				if (overlapGlobal > 0)
+				{
+					// shift y-position up to remove offset overlap
+					if (moveForSoftKeyboard)
+						yToGlobal = Math.max((softKeyboardEffectMarginTop * scaleFactor), (popUpY - overlapGlobal));
+					
+					// adjust height based on new y-position
+					if (resizeForSoftKeyboard)
+					{
+						// compute new overlap
+						overlapGlobal = (yToGlobal + popUpHeight) - softKeyboardRect.y;
+						
+						// adjust height if there is overlap
+						if (overlapGlobal > 0)
+							heightToGlobal = popUpHeight - overlapGlobal - (softKeyboardEffectMarginBottom * scaleFactor);
+					}
+				}
+				
+				if ((yToGlobal != popUpY) ||
+					(heightToGlobal != popUpHeight))
+				{
+					// convert to application coordinates, move to pixel boundaries
+					yToLocal = Math.floor(yToGlobal / scaleFactor);
+					heightToLocal = Math.floor(heightToGlobal / scaleFactor);
+					
+					// preserve minimum height
+					heightToLocal = Math.max(heightToLocal, getMinBoundsHeight());
+				}
+			}
+			
+			// Update state
+			_isSoftKeyboardEffectActive = isKeyboardOpen;
+			
+			var duration:Number = getStyle("softKeyboardEffectDuration");
+			
+			// Only create an effect when not snapping and the duration is
+			// non-negative. An effect will not be created by default if there is
+			// no change.
+			if (!snapPosition && (duration > 0))
+				softKeyboardEffect = createSoftKeyboardEffect(yToLocal, heightToLocal);
+			
+			if (softKeyboardEffect)
+			{
+				softKeyboardEffect.duration = duration;
+				
+				// Wait a frame so that any queued work can be completed by the framework
+				// and runtime before the effect starts.
+				addEventListener(Event.ENTER_FRAME, startEffect);
+			}
+			else
+			{
+				// No effect, snap. Set position and size explicitly.
+				this.y = yToLocal;
+				
+				if (isOpen)
+				{
+					this.height = heightToLocal;
+					
+					// Validate so that other listeners like Scroller get the 
+					// updated dimensions.
+					validateNow();
+					
+					if (isSoftKeyboardEffectActive)
+					{
+						installActiveResizeListener();
+						installSoftKeyboardStateChangeListeners();
+					}
+				}
+				else // if (!isOpen)
+				{
+					// Uninstall mouse delay and orientation change listeners
+					uninstallSoftKeyboardStateChangeListeners();
+					
+					// Clear explicit size leftover from Resize
+					softKeyboardEffectResetExplicitSize();
+					
+					// Clear start values
+					softKeyboardEffectCachedYPosition = NaN;
+					setSoftKeyboardEffectExplicitWidthFlag(false);
+					setSoftKeyboardEffectExplicitHeightFlag(false);
+					setSoftKeyboardEffectCachedHeight(NaN);
+				}
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 *  Start waiting for a (mouseDown, mouseUp) event sequence before effect
+		 *  plays.
+		 */
+		/*private function setPendingSoftKeyboardEvent(event:SoftKeyboardEvent):void
+		{
+			softKeyboardEffectPendingEventType = event.type;
+			
+			// If the mouseDown event was already received, wait indefinitely
+			// for mouseUp. If the soft keyboard event fired before mouseDown,
+			// start a timer.
+			if (!isMouseDown)
+			{
+				softKeyboardEffectPendingEventTimer = new Timer(softKeyboardEffectPendingEffectDelay, 1);
+				softKeyboardEffectPendingEventTimer.addEventListener(TimerEvent.TIMER_COMPLETE, pendingEffectTimer_timerCompleteHandler);
+				softKeyboardEffectPendingEventTimer.start();
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  Listeners installed just before the soft keyboard effect makes changes
+		 *  to the original position and height.
+		 */
+		private function installSoftKeyboardStateChangeListeners():void
+		{/*
+			if (!softKeyboardStateChangeListenersInstalled)
+			{
+				// Listen for mouseDown event on the pop-up and delay the soft
+				// keyboard effect until mouseUp. This allows button click
+				// events to complete normally before the button is re-positioned.
+				// See SDK-31534.
+				var sandboxRoot:UIComponent = systemManager.getSandboxRoot();
+				addEventListener(MouseEvent.MOUSE_DOWN, mouseHandler);
+				
+				// Listen for mouseUp events anywhere to play the effect. See SDK-31534.
+				sandboxRoot.addEventListener(MouseEvent.MOUSE_UP,
+					mouseHandler, true*/ /* useCapture */ /*);
+				sandboxRoot.addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,
+					systemManager_mouseUpHandler);
+				
+				// Listen for orientationChanging and orientationChange to suspend
+				// pop-up changes until the orientation change is complete.
+				// On iOS, the keyboard is deactivated after orientationChanging,
+				// then immediately activated after orientationChange is complete.
+				// On Android, the keyboard is deactivated after orientationChanging,
+				// but not reactivated after orienationChange.
+				// On QNX, the keyboard is not deactivated at all. The keyboard is
+				// simply activated again after orientationChange.
+				softKeyboardEffectOrientationChanging = false;
+				
+				var smStage:Stage = systemManager.stage;
+				smStage.addEventListener("orientationChanging", stage_orientationChangingHandler);
+				smStage.addEventListener("orientationChange", stage_orientationChangeHandler);
+				
+				softKeyboardStateChangeListenersInstalled = true;
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function uninstallSoftKeyboardStateChangeListeners():void
+		{/*
+			if (softKeyboardStateChangeListenersInstalled)
+			{
+				// Uninstall effect delay handling
+				removeEventListener(MouseEvent.MOUSE_DOWN, mouseHandler);
+				
+				var sandboxRoot:UIComponent = systemManager.getSandboxRoot();
+				sandboxRoot.removeEventListener(MouseEvent.MOUSE_UP, mouseHandler, true*/ /* useCapture */ /*);
+				sandboxRoot.removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE, systemManager_mouseUpHandler);
+				
+				// Uninstall orientation change handling
+				var smStage:Stage = systemManager.stage;
+				smStage.removeEventListener("orientationChange", stage_orientationChangeHandler);
+				smStage.removeEventListener("orientationChanging", stage_orientationChangeHandler);
+				
+				softKeyboardStateChangeListenersInstalled = false;
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 *  Listeners installed during the phase after the initial activate effect
+		 *  is complete and before the deactive effect starts.
+		 */
+		private function installActiveResizeListener():void
+		{
+			if (!resizeListenerInstalled)
+			{
+				// Flag size changes while the soft keyboard effect is active (but
+				// not playing)
+				addEventListener("explicitWidthChanged", resizeHandler);
+				addEventListener("explicitHeightChanged", resizeHandler);
+				resizeListenerInstalled = true;
+			}
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function uninstallActiveResizeListener():void
+		{
+			if (resizeListenerInstalled)
+			{
+				// Uninstall resize listener
+				removeEventListener("explicitWidthChanged", resizeHandler);
+				removeEventListener("explicitHeightChanged", resizeHandler);
+				resizeListenerInstalled = false;
+			}
+		}
+		
+		/**
+		 *  @private
+		 *  Clear explicit size that remains after a Resize effect.
+		 */
+		mx_internal function softKeyboardEffectResetExplicitSize():void
+		{
+			// Only remove and restore listeners if they are currently installed.
+			var installed:Boolean = resizeListenerInstalled;
+			
+			if (installed)
+				uninstallActiveResizeListener();
+			
+			// Remove explicit settings if due to Resize effect
+			if (!softKeyboardEffectExplicitWidthFlag)
+				explicitWidth = NaN;
+			
+			if (!softKeyboardEffectExplicitHeightFlag)
+				explicitHeight = NaN;
+			
+			if (installed)
+				installActiveResizeListener();
+		}
+	}
+}
\ No newline at end of file
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ButtonBarBase.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ButtonBarBase.as
new file mode 100644
index 000000000..9099bc544
--- /dev/null
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ButtonBarBase.as
@@ -0,0 +1,873 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package spark.components.supportClasses
+{
+	/*
+	import flash.events.Event;
+	import flash.events.EventPhase;
+	import flash.events.FocusEvent;
+	import flash.events.KeyboardEvent;
+	import flash.events.MouseEvent;
+	import flash.ui.Keyboard;
+	*/
+	
+	import org.apache.royale.events.Event;
+	import mx.events.MouseEvent;
+	
+	import mx.collections.IList;
+	import mx.core.EventPriority;
+	import mx.core.IFactory;
+	// import mx.core.ISelectableList;
+	import mx.core.IVisualElement;
+	import mx.core.mx_internal;
+	import mx.events.FlexEvent;
+	import mx.events.IndexChangedEvent;
+	import mx.managers.IFocusManagerComponent;
+	
+	// import spark.components.ButtonBarButton;
+	// import spark.components.IItemRenderer;
+	import spark.components.supportClasses.ButtonBase;
+	import spark.events.IndexChangeEvent;
+	// import spark.events.RendererExistenceEvent;
+	
+	use namespace mx_internal;  // use of ListBase/setCurrentCaretIndex(index);
+	
+	//--------------------------------------
+	//  Styles
+	//--------------------------------------
+	
+	/**
+	 *  Orientation of the icon in relation to the label.
+	 *  Valid MXML values are <code>right</code>, <code>left</code>,
+	 *  <code>bottom</code>, and <code>top</code>.
+	 *
+	 *  <p>In ActionScript, you can use the following constants
+	 *  to set this property:
+	 *  <code>IconPlacement.RIGHT</code>,
+	 *  <code>IconPlacement.LEFT</code>,
+	 *  <code>IconPlacement.BOTTOM</code>, and
+	 *  <code>IconPlacement.TOP</code>.</p>
+	 *
+	 *  @default IconPlacement.LEFT
+	 * 
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 1.5
+	 *  @productversion Flex 4
+	 */
+	[Style(name="iconPlacement", type="String", enumeration="top,bottom,right,left", inherit="no")]
+	
+	//--------------------------------------
+	//  Other metadata
+	//--------------------------------------
+	
+	[AccessibilityClass(implementation="spark.accessibility.ButtonBarBaseAccImpl")]
+	
+	/**
+	 *  The ButtonBarBase class defines the common behavior for the ButtonBar, TabBar and similar subclasses.   
+	 *  This class does not add any new API however it refines selection, keyboard focus and keyboard navigation
+	 *  behavior for the control's ItemRenderer elements.   
+	 *  This base class is not intended to be instantiated directly.
+	 * 
+	 *  <p>Clicking on an ItemRenderer selects it by setting the <code>selectedIndex</code> and the 
+	 *  <code>caretIndex</code> properties.  If <code>requireSelection</code> is <code>false</code>, then clicking 
+	 *  again deselects it.  If the data provider is an <code>ISelectableList</code> object, then its 
+	 *  <code>selectedIndex</code> is set as well.</p> 
+	 * 
+	 *  <p>Arrow key events are handled by adjusting the <code>caretIndex</code>.    
+	 *  If <code>arrowKeysWrapFocus</code> is <code>true</code>, then the <code>caretIndex</code> wraps.  
+	 *  Pressing the Space key selects the ItemRenderer at the <code>caretIndex</code>.</p>
+	 * 
+	 *  <p>The <code>showsCaret</code> property of the ItemRenderer at <code>caretIndex</code> 
+	 *  is set to <code>true</code> when the ButtonBarBase object has focus and 
+	 *  the <code>caretIndex</code> was reached as a consequence
+	 *  of a keyboard gesture.   
+	 *  If the <code>caretIndex</code> was set as a side effect of responding to a 
+	 *  mouse click, then <code>showsCaret</code> is not set.</p>
+	 * 
+	 *  <p>The <code>allowDeselection</code> property of <code>ButtonBarButton</code> 
+	 *  ItemRenderers is set to <code>!requireSelection</code>.</p>
+	 *
+	 *  @mxml
+	 *
+	 *  <p>The <code>&lt;s:ButtonBarBase&gt;</code> tag inherits all of the tag 
+	 *  attributes of its superclass and adds no new tag attributes:</p>
+	 *
+	 *  <pre>
+	 *  &lt;s:ButtonBarBase/&gt;
+	 *  </pre> 
+	 * 
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 1.5
+	 *  @productversion Flex 4
+	 */ 
+	public class ButtonBarBase extends ListBase
+	{
+		// include "../../core/Version.as";    
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Class mixins
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Placeholder for mixin by ButtonBarBaseAccImpl.
+		 */
+		mx_internal static var createAccessibilityImplementation:Function;
+		
+		/**
+		 *  Constructor.
+		 * 
+		 *  <p>Initializes tab processing: tabbing to this component will give it the focus, but not 
+		 *  clicking on it with the mouse.  Tabbing to the children is disabled.</p> 
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4
+		 */
+		public function ButtonBarBase()
+		{
+			super();
+			
+			tabChildren = false;
+			tabEnabled = true;
+			tabFocusEnabled = true;
+			setCurrentCaretIndex(0);        
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Variables
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  If false, don't show the focusRing for the tab at caretIndex, see
+		 *  itemShowingCaret() below.
+		 * 
+		 *  If the caret index changes because of something other than a arrow
+		 *  or space keypress then we don't show the focus ring, i.e. we do not 
+		 *  set showsCaret=true for the item renderer at caretIndex.
+		 *     
+		 *  This flag is valid at commitProperties() time.  It's set to false
+		 *  if at least one selectedIndex change (see item_clickHandler()) occurred 
+		 *  because of a mouse click.
+		 */
+		private var enableFocusHighlight:Boolean = true;
+		
+		/**
+		 *  @private
+		 */    
+		private var inCollectionChangeHandler:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Used to distinguish item_clickHandler() calls initiated by the mouse, from calls
+		 *  initiated by pressing the space bar.
+		 */
+		private var inKeyUpHandler:Boolean = false;
+		
+		/**
+		 *  @private
+		 *  Index of item that is currently pressed by the
+		 *  spacebar.
+		 */
+		private var pressedIndex:Number;
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Overridden Properties
+		//
+		//--------------------------------------------------------------------------
+		
+		//----------------------------------
+		//  dataProvider
+		//----------------------------------
+		
+		[Inspectable(category="Data")]
+		
+		/**
+		 *  @private
+		 */    
+		/*override public function set dataProvider(value:IList):void
+		{
+			if (dataProvider is ISelectableList)
+			{
+				dataProvider.removeEventListener(FlexEvent.VALUE_COMMIT, dataProvider_changeHandler);
+				dataProvider.removeEventListener(IndexChangedEvent.CHANGE, dataProvider_changeHandler);
+			}
+			
+			if (value is ISelectableList)
+			{
+				value.addEventListener(FlexEvent.VALUE_COMMIT, dataProvider_changeHandler, false, 0, true);
+				value.addEventListener(IndexChangedEvent.CHANGE, dataProvider_changeHandler, false, 0, true);
+			}
+			
+			super.dataProvider = value;
+			
+			if (value is ISelectableList)
+				selectedIndex = ISelectableList(dataProvider).selectedIndex;
+		}*/    
+		
+		//----------------------------------
+		//  iconField
+		//----------------------------------
+		
+		/**
+		 *  @private
+		 */
+		private var _iconField:String = "icon";
+		
+		/**
+		 *  @private
+		 */
+		private var iconFieldOrFunctionChanged:Boolean; 
+		
+		/**
+		 *  The name of the field in the data provider items which serves
+		 *  as the icon to display.
+		 * 
+		 *  The <code>iconFunction</code> property overrides this property.
+		 *
+		 *  @default null
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4.5
+		 */
+		public function get iconField():String
+		{
+			return _iconField;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set iconField(value:String):void
+		{
+			if (value == _iconField)
+				return; 
+			
+			_iconField = value;
+			iconFieldOrFunctionChanged = true;
+			invalidateProperties();
+		}
+		
+		//----------------------------------
+		//  iconFunction
+		//----------------------------------
+		
+		/**
+		 *  @private
+		 */
+		private var _iconFunction:Function; 
+		
+		/**
+		 *  A user-supplied function to run on each item to determine its icon.  
+		 *  The <code>iconFunction</code> property overrides 
+		 *  the <code>iconField</code> property.
+		 *
+		 *  <p>You can supply an <code>iconFunction</code> that finds the 
+		 *  appropriate fields and returns a displayable icon. </p>
+		 *
+		 *  <p>The icon function takes a single argument which is the item in 
+		 *  the data provider and returns a valid BitmapImage source.</p>
+		 *  <pre>
+		 *  myIconFunction(item:Object):Object</pre>
+		 *
+		 *  @default null
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10
+		 *  @playerversion AIR 1.5
+		 *  @productversion Flex 4.5
+		 */
+		public function get iconFunction():Function
+		{
+			return _iconFunction;
+		}
+		
+		/**
+		 *  @private
+		 */
+		public function set iconFunction(value:Function):void
+		{
+			if (value == _iconFunction)
+				return; 
+			
+			_iconFunction = value;
+			iconFieldOrFunctionChanged = true;
+			invalidateProperties(); 
+		}
+		
+		//----------------------------------
+		//  requireSelection
+		//---------------------------------- 
+		
+		private var requireSelectionChanged:Boolean;
+		
+		[Inspectable(category="General", defaultValue="false")]
+		
+		/**
+		 *  @private
+		 *  See commitProperties(). 
+		 */
+		override public function set requireSelection(value:Boolean):void
+		{
+			if (value == requireSelection)
+				return;
+			
+			super.requireSelection = value;
+			requireSelectionChanged = true;
+			invalidateProperties();
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Overridden Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 *  Called by the initialize() method of UIComponent
+		 *  to hook in the accessibility code.
+		 */
+		/*override protected function initializeAccessibility():void
+		{
+			if (ButtonBarBase.createAccessibilityImplementation != null)
+				ButtonBarBase.createAccessibilityImplementation(this);
+		}*/
+		
+		/**
+		 *  @private
+		 *  if the collection is changing and the collection is a viewstack
+		 *  the viewstack will also adjust the selection and notify us
+		 *  via dataProvider_changeHandler so we want to 
+		 *  ignore calls to adjustSelection that the base class
+		 *  calls so we don't increment or decrement
+		 *  selectedIndex twice
+		 */
+		/*override protected function dataProvider_collectionChangeHandler(event:Event):void
+		{
+			inCollectionChangeHandler = true;
+			
+			super.dataProvider_collectionChangeHandler(event);
+			
+			inCollectionChangeHandler = false;
+			
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function adjustSelection(newIndex:int, add:Boolean=false):void
+		{
+			// see comment in dataProvider_collectionChangeHandler
+			if (inCollectionChangeHandler && dataProvider is ISelectableList)
+				return;
+			
+			super.adjustSelection(newIndex, add);
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function commitProperties():void
+		{
+			super.commitProperties();
+			
+			if (requireSelectionChanged && dataGroup)
+			{
+				requireSelectionChanged = false;
+				const n:int = dataGroup.numElements;
+				for (var i:int = 0; i < n; i++)
+				{
+					var renderer:ButtonBarButton = dataGroup.getElementAt(i) as ButtonBarButton;
+					if (renderer)
+						renderer.allowDeselection = !requireSelection;
+				}
+			}
+			
+			if (iconFieldOrFunctionChanged)
+			{
+				updateRendererIcons();
+				iconFieldOrFunctionChanged = false;
+			}
+			
+			enableFocusHighlight = true;
+		}  */  
+		
+		/**
+		 *  @private
+		 *  Return the item renderer at the specified index, or null.
+		 */
+		private function getItemRenderer(index:int):IVisualElement
+		{
+			if (!dataGroup || (index < 0) || (index >= dataGroup.numElements))
+				return null;
+			
+			return dataGroup.getElementAt(index) as IVisualElement;
+		}
+		
+		/**
+		 *  @private
+		 *  Called when setCurrentCaretIndex() moves the caret, or when it's moved as a consequence
+		 *  of items being moved/removed.   See ListBase/caretIndexAdjusted.
+		 */
+		/*override protected function itemShowingCaret(index:int, showsCaret:Boolean):void
+		{
+			super.itemShowingCaret(index, showsCaret);
+			
+			const renderer:IVisualElement = getItemRenderer(index);
+			if (renderer)
+			{
+				const hasFocus:Boolean = focusManager && (focusManager.getFocus() == this);
+				renderer.depth = (showsCaret) ? 1 : 0;
+				if (renderer is IItemRenderer)   
+					IItemRenderer(renderer).showsCaret = showsCaret && enableFocusHighlight && hasFocus;
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 *  Called when the focus is gained/lost by tabbing in or out.
+		 */
+		/*override public function drawFocus(isFocused:Boolean):void
+		{
+			const renderer:IVisualElement = getItemRenderer(caretIndex);
+			if (renderer)
+			{
+				renderer.depth = (isFocused) ? 1 : 0;
+				if (renderer is IItemRenderer)             
+					IItemRenderer(renderer).showsCaret = isFocused;
+			}
+		}*/    
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function itemSelected(index:int, selected:Boolean):void
+		{
+			super.itemSelected(index, selected);
+			
+			const renderer:IItemRenderer = getItemRenderer(index) as IItemRenderer;
+			if (renderer)
+			{
+				if (selected)
+					setCurrentCaretIndex(index);  // causes itemShowingCaret() call
+				renderer.selected = selected;
+			}
+			
+			if ((dataProvider is ISelectableList) && selected)
+				ISelectableList(dataProvider).selectedIndex = index;
+		}*/
+		
+		/**
+		 *  @private 
+		 *  Detected changes to iconPlacement and update as necessary.
+		 */ 
+		/*override public function styleChanged(styleProp:String):void 
+		{    
+			if (!styleProp || 
+				styleProp == "styleName" || styleProp == "iconPlacement")
+			{
+				// Cause icon association to reoccur, taking into consideration
+				// the new placement.
+				iconFieldOrFunctionChanged = true; 
+				invalidateProperties();
+			}
+			
+			super.styleChanged(styleProp);
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override public function updateRenderer(renderer:IVisualElement, itemIndex:int, data:Object):void
+		{
+			itemToIcon(renderer, data);
+			super.updateRenderer(renderer, itemIndex, data);
+		} */ 
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Methods
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Gets the index for several of a ButtonBar's Buttons, referencing them by the ButtonBarbutton's <code>label</code>.  
+		 *
+		 *  <p>The method takes an array of ButtonBarButtons label and an optional field name.</p>
+		 *  <pre>myButtonBar.getButtonIndices(["My Button Label1", "My Label2"])</pre>
+		 *
+		 *  @param labelValues Are the ButtonBarButton labels to find.
+		 *  @param fieldName Field used for comparing the label (optional)
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 11.1
+		 *  @playerversion AIR 3.4
+		 *  @productversion Flex 4.10
+		 */
+		public function getButtonIndices(labelValues:Array, fieldName:String = ""):Array
+		{
+			var buttonIndices:Array;
+			
+			
+			if (!dataGroup || labelValues.length < 1 || labelValues == null)
+			{
+				return [];
+			}
+			
+			if (fieldName == "" || fieldName == null)
+			{
+				return findRowIndices(labelField, labelValues);
+			}
+			else
+			{
+				return findRowIndices(fieldName, labelValues);
+			}
+		}
+		
+		
+		/**
+		 *  Allows changing the <code>enabled</code> property of a the child ButtonBarbutton's.
+		 *  It identifies the button given its label field (default) or an different optional field name may be passed. 
+		 *
+		 *  <p>The method takes a single ButtonBarButton label, a new <code>enabled</code> property value, and an optional field name to use as the comparison field.</p>
+		 *  <pre>
+		 *  myButtonBar.setButtonEnabled("My Button Label", false)</pre>
+		 *
+		 *  @param labelValue Is the ButtonBarButton label.
+		 *  @param enabledValue The buttons new enabled value.
+		 *  @param fieldName Field used to compare the label value against.
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 11.1
+		 *  @playerversion AIR 3.4
+		 *  @productversion Flex 4.10
+		 */
+		public function setButtonEnabled(labelValue:String, enabledValue:Boolean, fieldName:String = ""):void
+		{
+			setButtonsEnabled([labelValue], enabledValue, fieldName);
+		}
+		
+		
+		/**
+		 *  Allows changing the <code>enabled</code> property of several child ButtonBarbutton's.
+		 *  It identifies the buttons given their label fields (default) or an different optional field name may be passed. 
+		 *
+		 *  <p>The method takes an array of ButtonBarButton labels, a new <code>enabled</code> property value, and an optional field name to use as the comparison field.</p>
+		 *  <pre>
+		 *  myButtonBar.setButtonsEnabled(["My Button Label1", "My Label2"], false)</pre>
+		 *
+		 *  @param labelValues Is an array of ButtonBarButton labels.
+		 *  @param enabledValue The buttons new enabled value.
+		 *  @param fieldName Field used to compare the label value against.
+		 *
+		 *  @langversion 3.0
+		 *  @playerversion Flash 11.1
+		 *  @playerversion AIR 3.4
+		 *  @productversion Flex 4.10
+		 */
+		public function setButtonsEnabled(labelValues:Array, enabledValue:Boolean, fieldName:String = ""):void
+		{
+			/*var btnCurrent:ButtonBarButton = null;
+			var buttonIndices:Array;
+			var indicesTotal:uint = 0;
+			var loopingIndex:uint = 0;
+			
+			
+			buttonIndices = getButtonIndices(labelValues, fieldName);
+			indicesTotal = buttonIndices.length;
+			
+			if (indicesTotal == 0)
+			{
+				return;
+			}
+			
+			
+			for (loopingIndex; loopingIndex < indicesTotal; loopingIndex++)
+			{
+				btnCurrent = dataGroup.getElementAt(buttonIndices[loopingIndex]) as ButtonBarButton;
+				btnCurrent.enabled = enabledValue;
+			}*/
+		}
+		
+		
+		/**
+		 *  @private
+		 */
+		private function itemToIcon(renderer:IVisualElement, item:Object):void
+		{
+			if (!(renderer is ButtonBase))
+				return;
+			
+			// Assign iconPlacement if appropriate.
+			var iconPlacement:String = getStyle("iconPlacement");
+			if (iconPlacement)
+				ButtonBase(renderer).setStyle("iconPlacement", iconPlacement);
+			
+			// iconFunction takes precedence.
+			if (_iconFunction != null)
+			{
+				ButtonBase(renderer).setStyle("icon", _iconFunction(item));
+				return;
+			}
+			
+			// iconField
+			if (_iconField && 
+				_iconField.length > 0 && 
+				item is Object)
+			{
+				try
+				{
+					if (item[_iconField] != null)
+					{
+						ButtonBase(renderer).setStyle("icon", item[_iconField]);
+						return;
+					}
+				}
+				catch(e:Error)
+				{
+				}
+			}
+			
+			ButtonBase(renderer).clearStyle("icon");
+		}
+		
+		/**
+		 *  @private
+		 */
+		private function updateRendererIcons():void
+		{
+			/*if (!dataGroup)
+				return;
+			
+			const count:int = dataGroup.numElements;
+			for (var i:int = 0; i < count; i++)
+			{
+				var renderer:IItemRenderer = dataGroup.getElementAt(i) as IItemRenderer; 
+				if (renderer && renderer.data)
+					itemToIcon(renderer, renderer.data);
+			}*/
+		}
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Event Handlers
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  @private
+		 */
+		private function dataProvider_changeHandler(event:Event):void
+		{
+			/*var newSelectedIndex:int = ISelectableList(dataProvider).selectedIndex;
+			if (selectedIndex != newSelectedIndex)
+			{
+				selectedIndex = newSelectedIndex;
+				commitSelection(false);
+				dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
+			}*/
+		}
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function dataGroup_rendererAddHandler(event:RendererExistenceEvent):void
+		{
+			super.dataGroup_rendererAddHandler(event);
+			
+			const renderer:IVisualElement = event.renderer; 
+			if (renderer)
+			{
+				renderer.addEventListener(MouseEvent.CLICK, item_clickHandler);
+				if (renderer is IFocusManagerComponent)
+					IFocusManagerComponent(renderer).focusEnabled = false;
+				if (renderer is ButtonBarButton)
+					ButtonBarButton(renderer).allowDeselection = !requireSelection;
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function dataGroup_rendererRemoveHandler(event:RendererExistenceEvent):void
+		{   
+			super.dataGroup_rendererRemoveHandler(event);
+			
+			const renderer:IVisualElement = event.renderer;
+			if (renderer)
+				renderer.removeEventListener(MouseEvent.CLICK, item_clickHandler);
+		}*/
+		
+		/**
+		 *  @private
+		 *  Called synchronously when the space bar is pressed or the mouse is clicked. 
+		 */
+		private function item_clickHandler(event:MouseEvent):void
+		{
+			/*var newIndex:int;
+			if (event.currentTarget is IItemRenderer)
+				newIndex = IItemRenderer(event.currentTarget).itemIndex;
+			else
+				newIndex = dataGroup.getElementIndex(event.currentTarget as IVisualElement);
+			
+			var oldSelectedIndex:int = selectedIndex;
+			if (newIndex == selectedIndex)
+			{
+				if (!requireSelection)
+					setSelectedIndex(NO_SELECTION, true);
+			}
+			else
+				setSelectedIndex(newIndex, true);
+			
+			// Changing the selectedIndex typically causes a call to itemSelected() at 
+			// commitProperties() time.   We'll update the caretIndex then.  If this 
+			// method was -not- called as a consequence of a keypress, we will not show
+			// the focus highlight at caretIndex.  See itemShowingCaret().
+			
+			if (enableFocusHighlight && (selectedIndex != oldSelectedIndex))
+				enableFocusHighlight = inKeyUpHandler;*/
+		}
+		
+		/**
+		 *  @private
+		 *  Increment or decrement the caretIndex.  Wrap if arrowKeysWrapFocus=true.
+		 */
+		private function adjustCaretIndex(delta:int):void
+		{/*
+			if (!dataGroup || (caretIndex < 0))
+				return;
+			
+			const oldCaretIndex:int = caretIndex;
+			const length:int = dataGroup.numElements;
+			
+			if (arrowKeysWrapFocus)
+				setCurrentCaretIndex((caretIndex + delta + length) % length);
+			else
+				setCurrentCaretIndex(Math.min(length - 1, Math.max(0, caretIndex + delta)));
+			
+			if (oldCaretIndex != caretIndex)
+				dispatchEvent(new IndexChangeEvent(IndexChangeEvent.CARET_CHANGE, false, false, oldCaretIndex, caretIndex)); */
+		}
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function keyDownHandler(event:KeyboardEvent):void
+		{
+			if (event.eventPhase == EventPhase.BUBBLING_PHASE)
+				return;
+			
+			if (!enabled || !dataGroup || event.isDefaultPrevented())
+				return;
+			
+			// Block input if space bar is being held down.
+			if (!isNaN(pressedIndex))
+			{
+				event.preventDefault();
+				return;
+			}
+			
+			super.keyDownHandler(event);
+			
+			// If rtl layout, need to swap LEFT/UP and RIGHT/DOWN so correct action
+			// is done.
+			var keyCode:uint = mapKeycodeForLayoutDirection(event, true);
+			
+			switch (keyCode)
+			{
+				case Keyboard.UP:
+				case Keyboard.LEFT:
+				{
+					adjustCaretIndex(-1);
+					event.preventDefault();
+					break;
+				}
+				case Keyboard.DOWN:
+				case Keyboard.RIGHT:
+				{
+					adjustCaretIndex(+1);
+					event.preventDefault();
+					break;
+				}            
+				case Keyboard.SPACE:
+				{
+					const renderer:IItemRenderer = getItemRenderer(caretIndex) as IItemRenderer;
+					if (renderer && ((!renderer.selected && requireSelection) || !requireSelection))
+					{
+						renderer.dispatchEvent(event);
+						pressedIndex = caretIndex;
+					}
+					break;
+				}            
+			}
+		}*/
+		
+		/**
+		 *  @private
+		 */
+		/*override protected function keyUpHandler(event:KeyboardEvent):void
+		{
+			if (event.eventPhase == EventPhase.BUBBLING_PHASE)
+				return;
+			
+			if (!enabled)
+				return;
+			
+			super.keyUpHandler(event);
+			
+			switch (event.keyCode)
+			{
+				case Keyboard.SPACE:
+				{
+					inKeyUpHandler = true;
+					
+					// Need to check pressedIndex for NaN for the case when key up
+					// happens on an already selected renderer and under the condition
+					// that requireSelection=true.
+					if (!isNaN(pressedIndex))
+					{
+						// Dispatch key up to the previously pressed item in case focus was lost
+						// through other interaction (e.g. mouse clicks, etc...)
+						const renderer:IItemRenderer = getItemRenderer(pressedIndex) as IItemRenderer;
+						if (renderer && ((!renderer.selected && requireSelection) || !requireSelection))
+						{
+							renderer.dispatchEvent(event);
+							pressedIndex = NaN;
+						}
+					}
+					inKeyUpHandler = false;
+					break;
+				}            
+			}
+		}*/
+	}
+}
\ No newline at end of file
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ListBase.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ListBase.as
index 9a168bb64..660e28d40 100644
--- a/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ListBase.as
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/supportClasses/ListBase.as
@@ -196,7 +196,7 @@ public class ListBase  extends SkinnableComponent
      *  @private
      *  Static constant representing no item in focus. 
      */
-   // private static const NO_CARET:int = -1;
+   private static const NO_CARET:int = -1;
     
     /**
      *  @private
@@ -424,9 +424,9 @@ public class ListBase  extends SkinnableComponent
     /**
      *  @private
      */
-    /* mx_internal var _caretIndex:Number = NO_CARET; 
+    mx_internal var _caretIndex:Number = NO_CARET; 
     
-    [Bindable("caretChange")] */
+    [Bindable("caretChange")]
 
     /**
      *  Item that is currently in focus. 
@@ -438,10 +438,10 @@ public class ListBase  extends SkinnableComponent
      *  @playerversion AIR 1.5
      *  @productversion Royale 0.9.4
      */
-    /* public function get caretIndex():Number
+    public function get caretIndex():Number
     {
         return _caretIndex;
-    } */
+    }
     
     /**
      *  @private
@@ -1332,12 +1332,12 @@ public class ListBase  extends SkinnableComponent
     *  @playerversion AIR 3.4
     *  @productversion Royale 0.9.4
     */
-    /* public function findRowIndices(field:String, values:Array, patternType:String = RegExPatterns.EXACT):Array
+    public function findRowIndices(field:String, values:Array, patternType:String = RegExPatterns.EXACT):Array
     {
         var currentObject:Object = null;
         var regexList:Array = [];
         var matchedIndices:Array = [];
-        var dataProviderTotal:uint = 0;
+        /*var dataProviderTotal:uint = 0;
         var valuesTotal:uint = 0;
         var loopingDataProviderIndex:uint = 0;
         var loopingValuesIndex:uint = 0;
@@ -1378,11 +1378,11 @@ public class ListBase  extends SkinnableComponent
                 }
             }
 
-        }
+        }*/
 
 
         return matchedIndices;
-    } */
+    } 
 
 
     /**
@@ -1585,8 +1585,8 @@ public class ListBase  extends SkinnableComponent
      *  caret property to true as well as updating the backing variable. 
      * 
      */
-    /* mx_internal function setCurrentCaretIndex(value:Number):void
-    {
+    mx_internal function setCurrentCaretIndex(value:Number):void
+    {/*
         if (value == caretIndex)
             return;
         
@@ -1603,9 +1603,9 @@ public class ListBase  extends SkinnableComponent
             
             const validIndex:Boolean = dataProvider && (_caretIndex >= 0) && (_caretIndex < dataProvider.length);
             caretItem = (validIndex) ? dataProvider.getItemAt(_caretIndex) : undefined;
-        }
+        }*/
     }
-     */
+    
     /**
      *  @private
      *  The selection validation and commitment workhorse method. 
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/modules/Module.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/modules/Module.as
new file mode 100644
index 000000000..8986d28bc
--- /dev/null
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/modules/Module.as
@@ -0,0 +1,89 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package spark.modules
+{
+	// import flash.events.Event;
+	import org.apache.royale.events.Event;
+	
+	// import mx.core.ContainerCreationPolicy;
+	import mx.modules.IModule;
+	import spark.components.SkinnableContainer;
+	
+	[Frame(factoryClass="mx.core.FlexModuleFactory")]
+	
+	//--------------------------------------
+	//  Other metadata
+	//--------------------------------------
+	
+	/**
+	 *  Modules are not supported for AIR mobile applications.
+	 */
+	[DiscouragedForProfile("mobileDevice")]
+	
+	/**
+	 *  The base class for MXML-based dynamically-loadable modules. You extend this
+	 *  class in MXML by using the <code>&lt;s:Module&gt;</code> tag in an MXML file, as the
+	 *  following example shows:
+	 *  
+	 *  <pre>
+	 *  &lt;?xml version="1.0"?&gt;
+	 *  &lt;!-- This module loads an image. --&gt;
+	 *  &lt;s:Module  width="100%" height="100%" xmlns:s="library://ns.adobe.com/flex/spark"&gt;
+	 *  
+	 *    &lt;s:Image source="trinity.gif"/&gt;
+	 *  
+	 *  &lt;/s:Module&gt;
+	 *  </pre>
+	 *  
+	 *  @see mx.modules.ModuleManager
+	 *  @see spark.modules.ModuleLoader
+	 * 
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10.2
+	 *  @playerversion AIR 2.5
+	 *  @productversion Flex 4.5
+	 */
+	public class Module extends SkinnableContainer implements IModule
+	{
+		// include "../core/Version.as";
+		
+		
+		//--------------------------------------------------------------------------
+		//
+		//  Constructor
+		//
+		//--------------------------------------------------------------------------
+		
+		/**
+		 *  Constructor. 
+		 *  
+		 *  @langversion 3.0
+		 *  @playerversion Flash 10.2
+		 *  @playerversion AIR 2.5
+		 *  @productversion Flex 4.5
+		 */
+		public function Module()
+		{
+			super();
+		}
+		
+	}
+	
+}


 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
users@infra.apache.org


With regards,
Apache Git Services

Mime
View raw message