home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / ComboBox.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  32.8 KB  |  1,052 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.FocusEvent;
  6.    import flash.events.KeyboardEvent;
  7.    import flash.events.MouseEvent;
  8.    import flash.geom.Matrix;
  9.    import flash.geom.Point;
  10.    import flash.geom.Rectangle;
  11.    import flash.text.TextLineMetrics;
  12.    import flash.ui.Keyboard;
  13.    import mx.collections.ArrayCollection;
  14.    import mx.collections.CursorBookmark;
  15.    import mx.controls.dataGridClasses.DataGridListData;
  16.    import mx.controls.listClasses.BaseListData;
  17.    import mx.controls.listClasses.IDropInListItemRenderer;
  18.    import mx.controls.listClasses.IListItemRenderer;
  19.    import mx.controls.listClasses.ListBase;
  20.    import mx.controls.listClasses.ListData;
  21.    import mx.core.ClassFactory;
  22.    import mx.core.EdgeMetrics;
  23.    import mx.core.FlexVersion;
  24.    import mx.core.IDataRenderer;
  25.    import mx.core.IFactory;
  26.    import mx.core.ScrollPolicy;
  27.    import mx.core.UIComponent;
  28.    import mx.core.UIComponentGlobals;
  29.    import mx.core.mx_internal;
  30.    import mx.effects.Tween;
  31.    import mx.events.CollectionEvent;
  32.    import mx.events.CollectionEventKind;
  33.    import mx.events.DropdownEvent;
  34.    import mx.events.FlexEvent;
  35.    import mx.events.FlexMouseEvent;
  36.    import mx.events.InterManagerRequest;
  37.    import mx.events.ListEvent;
  38.    import mx.events.SandboxMouseEvent;
  39.    import mx.events.ScrollEvent;
  40.    import mx.events.ScrollEventDetail;
  41.    import mx.managers.ISystemManager;
  42.    import mx.managers.PopUpManager;
  43.    import mx.styles.CSSStyleDeclaration;
  44.    import mx.styles.StyleManager;
  45.    
  46.    use namespace mx_internal;
  47.    
  48.    public class ComboBox extends ComboBase implements IDataRenderer, IDropInListItemRenderer, IListItemRenderer
  49.    {
  50.       mx_internal static var createAccessibilityImplementation:Function;
  51.       
  52.       mx_internal static const VERSION:String = "3.5.0.12683";
  53.       
  54.       private var _labelField:String = "label";
  55.       
  56.       private var dropdownBorderStyle:String = "solid";
  57.       
  58.       private var implicitSelectedIndex:Boolean = false;
  59.       
  60.       private var _selectedIndexOnDropdown:int = -1;
  61.       
  62.       private var preferredDropdownWidth:Number;
  63.       
  64.       private var collectionChanged:Boolean = false;
  65.       
  66.       private var labelFunctionChanged:Boolean;
  67.       
  68.       private var selectedItemSet:Boolean;
  69.       
  70.       private var _dropdownWidth:Number = 100;
  71.       
  72.       private var inTween:Boolean = false;
  73.       
  74.       private var _oldIndex:int;
  75.       
  76.       private var tweenUp:Boolean = false;
  77.       
  78.       private var tween:Tween = null;
  79.       
  80.       private var labelFieldChanged:Boolean;
  81.       
  82.       private var _dropdown:ListBase;
  83.       
  84.       private var _dropdownFactory:IFactory = new ClassFactory(List);
  85.       
  86.       private var explicitText:Boolean;
  87.       
  88.       private var _prompt:String;
  89.       
  90.       private var _data:Object;
  91.       
  92.       private var bInKeyDown:Boolean = false;
  93.       
  94.       private var promptChanged:Boolean = false;
  95.       
  96.       private var _rowCount:int = 5;
  97.       
  98.       private var bRemoveDropdown:Boolean = false;
  99.       
  100.       private var _showingDropdown:Boolean = false;
  101.       
  102.       private var triggerEvent:Event;
  103.       
  104.       private var _listData:BaseListData;
  105.       
  106.       private var _itemRenderer:IFactory;
  107.       
  108.       private var _labelFunction:Function;
  109.       
  110.       public function ComboBox()
  111.       {
  112.          super();
  113.          dataProvider = new ArrayCollection();
  114.          mx_internal::useFullDropdownSkin = true;
  115.          mx_internal::wrapDownArrowButton = false;
  116.          addEventListener("unload",unloadHandler);
  117.          addEventListener(Event.REMOVED_FROM_STAGE,removedFromStageHandler);
  118.       }
  119.       
  120.       override protected function calculatePreferredSizeFromData(param1:int) : Object
  121.       {
  122.          var _loc6_:TextLineMetrics = null;
  123.          var _loc8_:Object = null;
  124.          var _loc9_:String = null;
  125.          var _loc2_:Number = 0;
  126.          var _loc3_:Number = 0;
  127.          var _loc4_:CursorBookmark = !!iterator ? iterator.bookmark : null;
  128.          iterator.seek(CursorBookmark.FIRST,0);
  129.          var _loc5_:* = iterator != null;
  130.          var _loc7_:int = 0;
  131.          while(_loc7_ < param1)
  132.          {
  133.             if(_loc5_)
  134.             {
  135.                _loc8_ = !!iterator ? iterator.current : null;
  136.             }
  137.             else
  138.             {
  139.                _loc8_ = null;
  140.             }
  141.             _loc9_ = itemToLabel(_loc8_);
  142.             _loc6_ = measureText(_loc9_);
  143.             _loc2_ = Math.max(_loc2_,_loc6_.width);
  144.             _loc3_ = Math.max(_loc3_,_loc6_.height);
  145.             if(iterator)
  146.             {
  147.                iterator.moveNext();
  148.             }
  149.             _loc7_++;
  150.          }
  151.          if(prompt)
  152.          {
  153.             _loc6_ = measureText(prompt);
  154.             _loc2_ = Math.max(_loc2_,_loc6_.width);
  155.             _loc3_ = Math.max(_loc3_,_loc6_.height);
  156.          }
  157.          _loc2_ += getStyle("paddingLeft") + getStyle("paddingRight");
  158.          if(iterator)
  159.          {
  160.             iterator.seek(_loc4_,0);
  161.          }
  162.          return {
  163.             "width":_loc2_,
  164.             "height":_loc3_
  165.          };
  166.       }
  167.       
  168.       private function dropdown_scrollHandler(param1:Event) : void
  169.       {
  170.          var _loc2_:ScrollEvent = null;
  171.          if(param1 is ScrollEvent)
  172.          {
  173.             _loc2_ = ScrollEvent(param1);
  174.             if(_loc2_.detail == ScrollEventDetail.THUMB_TRACK || _loc2_.detail == ScrollEventDetail.THUMB_POSITION || _loc2_.detail == ScrollEventDetail.LINE_UP || _loc2_.detail == ScrollEventDetail.LINE_DOWN)
  175.             {
  176.                dispatchEvent(_loc2_);
  177.             }
  178.          }
  179.       }
  180.       
  181.       public function get dropdown() : ListBase
  182.       {
  183.          return getDropdown();
  184.       }
  185.       
  186.       public function get selectedLabel() : String
  187.       {
  188.          var _loc1_:Object = selectedItem;
  189.          return itemToLabel(_loc1_);
  190.       }
  191.       
  192.       override protected function focusOutHandler(param1:FocusEvent) : void
  193.       {
  194.          if(_showingDropdown && Boolean(_dropdown))
  195.          {
  196.             if(!param1.relatedObject || !_dropdown.contains(param1.relatedObject))
  197.             {
  198.                close();
  199.             }
  200.          }
  201.          super.focusOutHandler(param1);
  202.       }
  203.       
  204.       private function destroyDropdown() : void
  205.       {
  206.          if(inTween)
  207.          {
  208.             tween.endTween();
  209.          }
  210.          displayDropdown(false,null,false);
  211.       }
  212.       
  213.       [Bindable("dropdownWidthChanged")]
  214.       public function get dropdownWidth() : Number
  215.       {
  216.          return _dropdownWidth;
  217.       }
  218.       
  219.       private function unloadHandler(param1:Event) : void
  220.       {
  221.          if(inTween)
  222.          {
  223.             UIComponent.resumeBackgroundProcessing();
  224.             inTween = false;
  225.          }
  226.          if(_dropdown)
  227.          {
  228.             _dropdown.parent.removeChild(_dropdown);
  229.          }
  230.       }
  231.       
  232.       public function open() : void
  233.       {
  234.          displayDropdown(true);
  235.       }
  236.       
  237.       public function set data(param1:Object) : void
  238.       {
  239.          var _loc2_:* = undefined;
  240.          _data = param1;
  241.          if(Boolean(_listData) && _listData is DataGridListData)
  242.          {
  243.             _loc2_ = _data[DataGridListData(_listData).dataField];
  244.          }
  245.          else if(_listData is ListData && ListData(_listData).labelField in _data)
  246.          {
  247.             _loc2_ = _data[ListData(_listData).labelField];
  248.          }
  249.          else
  250.          {
  251.             _loc2_ = _data;
  252.          }
  253.          if(_loc2_ !== undefined && !selectedItemSet)
  254.          {
  255.             selectedItem = _loc2_;
  256.             selectedItemSet = false;
  257.          }
  258.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  259.       }
  260.       
  261.       [Bindable("resize")]
  262.       public function get rowCount() : int
  263.       {
  264.          return Math.max(1,Math.min(collection.length,_rowCount));
  265.       }
  266.       
  267.       override protected function textInput_changeHandler(param1:Event) : void
  268.       {
  269.          super.textInput_changeHandler(param1);
  270.          dispatchChangeEvent(param1,-1,-2);
  271.       }
  272.       
  273.       private function dropdown_itemRollOutHandler(param1:Event) : void
  274.       {
  275.          dispatchEvent(param1);
  276.       }
  277.       
  278.       override protected function measure() : void
  279.       {
  280.          super.measure();
  281.          measuredMinWidth = Math.max(measuredWidth,DEFAULT_MEASURED_MIN_WIDTH);
  282.          var _loc1_:Number = measureText("M").height + 6;
  283.          var _loc2_:EdgeMetrics = borderMetrics;
  284.          measuredMinHeight = measuredHeight = Math.max(_loc1_ + _loc2_.top + _loc2_.bottom,DEFAULT_MEASURED_MIN_HEIGHT);
  285.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  286.          {
  287.             measuredMinHeight = measuredHeight = measuredHeight + (getStyle("paddingTop") + getStyle("paddingBottom"));
  288.          }
  289.       }
  290.       
  291.       private function dropdown_itemRollOverHandler(param1:Event) : void
  292.       {
  293.          dispatchEvent(param1);
  294.       }
  295.       
  296.       public function get prompt() : String
  297.       {
  298.          return _prompt;
  299.       }
  300.       
  301.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  302.       {
  303.          var _loc2_:int = 0;
  304.          if(!enabled)
  305.          {
  306.             return;
  307.          }
  308.          if(param1.target == textInput)
  309.          {
  310.             return;
  311.          }
  312.          if(param1.ctrlKey && param1.keyCode == Keyboard.DOWN)
  313.          {
  314.             displayDropdown(true,param1);
  315.             param1.stopPropagation();
  316.          }
  317.          else if(param1.ctrlKey && param1.keyCode == Keyboard.UP)
  318.          {
  319.             close(param1);
  320.             param1.stopPropagation();
  321.          }
  322.          else if(param1.keyCode == Keyboard.ESCAPE)
  323.          {
  324.             if(_showingDropdown)
  325.             {
  326.                if(_oldIndex != _dropdown.selectedIndex)
  327.                {
  328.                   selectedIndex = _oldIndex;
  329.                }
  330.                displayDropdown(false);
  331.                param1.stopPropagation();
  332.             }
  333.          }
  334.          else if(param1.keyCode == Keyboard.ENTER)
  335.          {
  336.             if(_showingDropdown)
  337.             {
  338.                close();
  339.                param1.stopPropagation();
  340.             }
  341.          }
  342.          else if(!editable || param1.keyCode == Keyboard.UP || param1.keyCode == Keyboard.DOWN || param1.keyCode == Keyboard.PAGE_UP || param1.keyCode == Keyboard.PAGE_DOWN)
  343.          {
  344.             _loc2_ = selectedIndex;
  345.             bInKeyDown = _showingDropdown;
  346.             dropdown.dispatchEvent(param1.clone());
  347.             param1.stopPropagation();
  348.             bInKeyDown = false;
  349.          }
  350.       }
  351.       
  352.       public function set dropdownWidth(param1:Number) : void
  353.       {
  354.          _dropdownWidth = param1;
  355.          preferredDropdownWidth = param1;
  356.          if(_dropdown)
  357.          {
  358.             _dropdown.setActualSize(param1,_dropdown.height);
  359.          }
  360.          dispatchEvent(new Event("dropdownWidthChanged"));
  361.       }
  362.       
  363.       [Bindable("labelFieldChanged")]
  364.       public function get labelField() : String
  365.       {
  366.          return _labelField;
  367.       }
  368.       
  369.       public function set dropdownFactory(param1:IFactory) : void
  370.       {
  371.          _dropdownFactory = param1;
  372.          dispatchEvent(new Event("dropdownFactoryChanged"));
  373.       }
  374.       
  375.       [Bindable("collectionChange")]
  376.       override public function set dataProvider(param1:Object) : void
  377.       {
  378.          mx_internal::selectionChanged = true;
  379.          super.dataProvider = param1;
  380.          destroyDropdown();
  381.          invalidateProperties();
  382.          invalidateSize();
  383.       }
  384.       
  385.       mx_internal function get isShowingDropdown() : Boolean
  386.       {
  387.          return _showingDropdown;
  388.       }
  389.       
  390.       override protected function collectionChangeHandler(param1:Event) : void
  391.       {
  392.          var _loc3_:CollectionEvent = null;
  393.          var _loc2_:int = selectedIndex;
  394.          super.collectionChangeHandler(param1);
  395.          if(param1 is CollectionEvent)
  396.          {
  397.             _loc3_ = CollectionEvent(param1);
  398.             if(collection.length == 0)
  399.             {
  400.                if(!mx_internal::selectedIndexChanged && !mx_internal::selectedItemChanged)
  401.                {
  402.                   if(super.selectedIndex != -1)
  403.                   {
  404.                      super.selectedIndex = -1;
  405.                   }
  406.                   implicitSelectedIndex = true;
  407.                   invalidateDisplayList();
  408.                }
  409.                if(Boolean(textInput) && !editable)
  410.                {
  411.                   textInput.text = "";
  412.                }
  413.             }
  414.             else if(_loc3_.kind == CollectionEventKind.ADD)
  415.             {
  416.                if(collection.length != _loc3_.items.length)
  417.                {
  418.                   return;
  419.                }
  420.                if(selectedIndex == -1 && _prompt == null)
  421.                {
  422.                   selectedIndex = 0;
  423.                }
  424.             }
  425.             else if(_loc3_.kind == CollectionEventKind.UPDATE)
  426.             {
  427.                if(_loc3_.location == selectedIndex || _loc3_.items[0].source == selectedItem)
  428.                {
  429.                   mx_internal::selectionChanged = true;
  430.                }
  431.             }
  432.             else
  433.             {
  434.                if(_loc3_.kind == CollectionEventKind.REPLACE)
  435.                {
  436.                   return;
  437.                }
  438.                if(_loc3_.kind == CollectionEventKind.RESET)
  439.                {
  440.                   collectionChanged = true;
  441.                   if(!mx_internal::selectedIndexChanged && !mx_internal::selectedItemChanged)
  442.                   {
  443.                      selectedIndex = !!prompt ? -1 : 0;
  444.                   }
  445.                   invalidateProperties();
  446.                }
  447.             }
  448.             invalidateDisplayList();
  449.             destroyDropdown();
  450.          }
  451.       }
  452.       
  453.       mx_internal function onTweenEnd(param1:Number) : void
  454.       {
  455.          if(_dropdown)
  456.          {
  457.             _dropdown.scrollRect = null;
  458.             inTween = false;
  459.             _dropdown.enabled = true;
  460.             _dropdown.visible = _showingDropdown;
  461.          }
  462.          if(bRemoveDropdown)
  463.          {
  464.             _dropdown.removeEventListener(FlexMouseEvent.MOUSE_DOWN_OUTSIDE,dropdown_mouseOutsideHandler);
  465.             _dropdown.removeEventListener(FlexMouseEvent.MOUSE_WHEEL_OUTSIDE,dropdown_mouseOutsideHandler);
  466.             _dropdown.removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,dropdown_mouseOutsideHandler);
  467.             _dropdown.removeEventListener(SandboxMouseEvent.MOUSE_WHEEL_SOMEWHERE,dropdown_mouseOutsideHandler);
  468.             PopUpManager.removePopUp(_dropdown);
  469.             _dropdown = null;
  470.             bRemoveDropdown = false;
  471.          }
  472.          UIComponent.resumeBackgroundProcessing();
  473.          var _loc2_:DropdownEvent = new DropdownEvent(_showingDropdown ? DropdownEvent.OPEN : DropdownEvent.CLOSE);
  474.          _loc2_.triggerEvent = triggerEvent;
  475.          dispatchEvent(_loc2_);
  476.       }
  477.       
  478.       [Bindable("dataChange")]
  479.       public function get listData() : BaseListData
  480.       {
  481.          return _listData;
  482.       }
  483.       
  484.       private function getDropdown() : ListBase
  485.       {
  486.          var _loc2_:String = null;
  487.          var _loc3_:CSSStyleDeclaration = null;
  488.          if(!initialized)
  489.          {
  490.             return null;
  491.          }
  492.          if(!mx_internal::hasDropdown())
  493.          {
  494.             _loc2_ = getStyle("dropDownStyleName");
  495.             if(_loc2_ == null)
  496.             {
  497.                _loc2_ = getStyle("dropdownStyleName");
  498.             }
  499.             _dropdown = dropdownFactory.newInstance();
  500.             _dropdown.visible = false;
  501.             _dropdown.focusEnabled = false;
  502.             _dropdown.owner = this;
  503.             if(itemRenderer)
  504.             {
  505.                _dropdown.itemRenderer = itemRenderer;
  506.             }
  507.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  508.             {
  509.                _dropdown.styleName = this;
  510.             }
  511.             if(_loc2_)
  512.             {
  513.                if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  514.                {
  515.                   _loc3_ = StyleManager.getStyleDeclaration("." + _loc2_);
  516.                   if(_loc3_)
  517.                   {
  518.                      _dropdown.styleDeclaration = _loc3_;
  519.                   }
  520.                }
  521.                else
  522.                {
  523.                   _dropdown.styleName = _loc2_;
  524.                }
  525.             }
  526.             else if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  527.             {
  528.                _dropdown.setStyle("cornerRadius",0);
  529.             }
  530.             PopUpManager.addPopUp(_dropdown,this);
  531.             _dropdown.setStyle("selectionDuration",0);
  532.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0 && dropdownBorderStyle && dropdownBorderStyle != "")
  533.             {
  534.                _dropdown.setStyle("borderStyle",dropdownBorderStyle);
  535.             }
  536.             if(!dataProvider)
  537.             {
  538.                dataProvider = new ArrayCollection();
  539.             }
  540.             _dropdown.dataProvider = dataProvider;
  541.             _dropdown.rowCount = rowCount;
  542.             _dropdown.width = _dropdownWidth;
  543.             _dropdown.selectedIndex = selectedIndex;
  544.             _oldIndex = selectedIndex;
  545.             _dropdown.verticalScrollPolicy = ScrollPolicy.AUTO;
  546.             _dropdown.labelField = _labelField;
  547.             _dropdown.labelFunction = itemToLabel;
  548.             _dropdown.allowDragSelection = true;
  549.             _dropdown.addEventListener("change",dropdown_changeHandler);
  550.             _dropdown.addEventListener(ScrollEvent.SCROLL,dropdown_scrollHandler);
  551.             _dropdown.addEventListener(ListEvent.ITEM_ROLL_OVER,dropdown_itemRollOverHandler);
  552.             _dropdown.addEventListener(ListEvent.ITEM_ROLL_OUT,dropdown_itemRollOutHandler);
  553.             _dropdown.addEventListener(ListEvent.ITEM_CLICK,dropdown_itemClickHandler);
  554.             UIComponentGlobals.mx_internal::layoutManager.validateClient(_dropdown,true);
  555.             _dropdown.setActualSize(_dropdownWidth,_dropdown.getExplicitOrMeasuredHeight());
  556.             _dropdown.validateDisplayList();
  557.             _dropdown.cacheAsBitmap = true;
  558.             systemManager.addEventListener(Event.RESIZE,stage_resizeHandler,false,0,true);
  559.          }
  560.          var _loc1_:Matrix = transform.concatenatedMatrix;
  561.          _dropdown.scaleX = _loc1_.a;
  562.          _dropdown.scaleY = _loc1_.d;
  563.          return _dropdown;
  564.       }
  565.       
  566.       private function stage_resizeHandler(param1:Event) : void
  567.       {
  568.          destroyDropdown();
  569.       }
  570.       
  571.       override protected function downArrowButton_buttonDownHandler(param1:FlexEvent) : void
  572.       {
  573.          if(_showingDropdown)
  574.          {
  575.             close(param1);
  576.          }
  577.          else
  578.          {
  579.             displayDropdown(true,param1);
  580.          }
  581.       }
  582.       
  583.       [Bindable("valueCommit")]
  584.       [Bindable("collectionChange")]
  585.       [Bindable("change")]
  586.       override public function set selectedItem(param1:Object) : void
  587.       {
  588.          selectedItemSet = true;
  589.          implicitSelectedIndex = false;
  590.          super.selectedItem = param1;
  591.       }
  592.       
  593.       override protected function initializeAccessibility() : void
  594.       {
  595.          if(ComboBox.mx_internal::createAccessibilityImplementation != null)
  596.          {
  597.             ComboBox.mx_internal::createAccessibilityImplementation(this);
  598.          }
  599.       }
  600.       
  601.       public function itemToLabel(param1:Object, ... rest) : String
  602.       {
  603.          var item:Object = param1;
  604.          if(item == null)
  605.          {
  606.             return "";
  607.          }
  608.          if(labelFunction != null)
  609.          {
  610.             return labelFunction(item);
  611.          }
  612.          if(typeof item == "object")
  613.          {
  614.             try
  615.             {
  616.                if(item[labelField] != null)
  617.                {
  618.                   item = item[labelField];
  619.                }
  620.             }
  621.             catch(e:Error)
  622.             {
  623.             }
  624.          }
  625.          else if(typeof item == "xml")
  626.          {
  627.             try
  628.             {
  629.                if(item[labelField].length() != 0)
  630.                {
  631.                   item = item[labelField];
  632.                }
  633.             }
  634.             catch(e:Error)
  635.             {
  636.             }
  637.          }
  638.          if(typeof item == "string")
  639.          {
  640.             return String(item);
  641.          }
  642.          try
  643.          {
  644.             return item.toString();
  645.          }
  646.          catch(e:Error)
  647.          {
  648.          }
  649.          return " ";
  650.       }
  651.       
  652.       [Bindable("dataChange")]
  653.       public function get data() : Object
  654.       {
  655.          return _data;
  656.       }
  657.       
  658.       mx_internal function onTweenUpdate(param1:Number) : void
  659.       {
  660.          if(_dropdown)
  661.          {
  662.             _dropdown.scrollRect = new Rectangle(0,param1,_dropdown.width,_dropdown.height);
  663.          }
  664.       }
  665.       
  666.       private function removedFromStageHandler(param1:Event) : void
  667.       {
  668.          destroyDropdown();
  669.       }
  670.       
  671.       private function dropdown_mouseOutsideHandler(param1:Event) : void
  672.       {
  673.          var _loc2_:MouseEvent = null;
  674.          if(param1 is MouseEvent)
  675.          {
  676.             _loc2_ = MouseEvent(param1);
  677.             if(_loc2_.target != _dropdown)
  678.             {
  679.                return;
  680.             }
  681.             if(!hitTestPoint(_loc2_.stageX,_loc2_.stageY,true))
  682.             {
  683.                close(param1);
  684.             }
  685.          }
  686.          else if(param1 is SandboxMouseEvent)
  687.          {
  688.             close(param1);
  689.          }
  690.       }
  691.       
  692.       [Bindable("dropdownFactoryChanged")]
  693.       public function get dropdownFactory() : IFactory
  694.       {
  695.          return _dropdownFactory;
  696.       }
  697.       
  698.       override public function styleChanged(param1:String) : void
  699.       {
  700.          destroyDropdown();
  701.          super.styleChanged(param1);
  702.       }
  703.       
  704.       public function set prompt(param1:String) : void
  705.       {
  706.          _prompt = param1;
  707.          promptChanged = true;
  708.          invalidateProperties();
  709.       }
  710.       
  711.       override protected function commitProperties() : void
  712.       {
  713.          explicitText = mx_internal::textChanged;
  714.          super.commitProperties();
  715.          if(collectionChanged)
  716.          {
  717.             if(selectedIndex == -1 && implicitSelectedIndex && _prompt == null)
  718.             {
  719.                selectedIndex = 0;
  720.             }
  721.             mx_internal::selectedIndexChanged = true;
  722.             collectionChanged = false;
  723.          }
  724.          if(promptChanged && prompt != null && selectedIndex == -1)
  725.          {
  726.             promptChanged = false;
  727.             textInput.text = prompt;
  728.          }
  729.       }
  730.       
  731.       mx_internal function hasDropdown() : Boolean
  732.       {
  733.          return _dropdown != null;
  734.       }
  735.       
  736.       public function set listData(param1:BaseListData) : void
  737.       {
  738.          _listData = param1;
  739.       }
  740.       
  741.       public function set labelField(param1:String) : void
  742.       {
  743.          _labelField = param1;
  744.          labelFieldChanged = true;
  745.          invalidateDisplayList();
  746.          dispatchEvent(new Event("labelFieldChanged"));
  747.       }
  748.       
  749.       public function set labelFunction(param1:Function) : void
  750.       {
  751.          _labelFunction = param1;
  752.          labelFunctionChanged = true;
  753.          invalidateDisplayList();
  754.          dispatchEvent(new Event("labelFunctionChanged"));
  755.       }
  756.       
  757.       protected function get dropDownStyleFilters() : Object
  758.       {
  759.          return null;
  760.       }
  761.       
  762.       public function set rowCount(param1:int) : void
  763.       {
  764.          _rowCount = param1;
  765.          if(_dropdown)
  766.          {
  767.             _dropdown.rowCount = param1;
  768.          }
  769.       }
  770.       
  771.       private function dropdown_changeHandler(param1:Event) : void
  772.       {
  773.          var _loc2_:int = selectedIndex;
  774.          if(_dropdown)
  775.          {
  776.             selectedIndex = _dropdown.selectedIndex;
  777.          }
  778.          if(!_showingDropdown)
  779.          {
  780.             dispatchChangeEvent(param1,_loc2_,selectedIndex);
  781.          }
  782.          else if(!bInKeyDown)
  783.          {
  784.             close();
  785.          }
  786.       }
  787.       
  788.       private function dropdown_itemClickHandler(param1:ListEvent) : void
  789.       {
  790.          if(_showingDropdown)
  791.          {
  792.             close();
  793.          }
  794.       }
  795.       
  796.       [Bindable("labelFunctionChanged")]
  797.       public function get labelFunction() : Function
  798.       {
  799.          return _labelFunction;
  800.       }
  801.       
  802.       [Bindable("valueCommit")]
  803.       [Bindable("collectionChange")]
  804.       [Bindable("change")]
  805.       override public function set selectedIndex(param1:int) : void
  806.       {
  807.          super.selectedIndex = param1;
  808.          if(param1 >= 0)
  809.          {
  810.             mx_internal::selectionChanged = true;
  811.          }
  812.          implicitSelectedIndex = false;
  813.          invalidateDisplayList();
  814.          if(textInput && !mx_internal::textChanged && param1 >= 0)
  815.          {
  816.             textInput.text = selectedLabel;
  817.          }
  818.          else if(Boolean(textInput) && Boolean(prompt))
  819.          {
  820.             textInput.text = prompt;
  821.          }
  822.       }
  823.       
  824.       private function dispatchChangeEvent(param1:Event, param2:int, param3:int) : void
  825.       {
  826.          var _loc4_:Event = null;
  827.          if(param2 != param3)
  828.          {
  829.             _loc4_ = param1 is ListEvent ? param1 : new ListEvent("change");
  830.             dispatchEvent(_loc4_);
  831.          }
  832.       }
  833.       
  834.       private function displayDropdown(param1:Boolean, param2:Event = null, param3:Boolean = true) : void
  835.       {
  836.          var _loc4_:Number = NaN;
  837.          var _loc5_:Number = NaN;
  838.          var _loc6_:Number = NaN;
  839.          var _loc7_:Function = null;
  840.          var _loc11_:Rectangle = null;
  841.          var _loc12_:InterManagerRequest = null;
  842.          var _loc13_:int = 0;
  843.          var _loc14_:Number = NaN;
  844.          if(!initialized || param1 == _showingDropdown)
  845.          {
  846.             return;
  847.          }
  848.          var _loc8_:Point = new Point(0,unscaledHeight);
  849.          _loc8_ = localToGlobal(_loc8_);
  850.          var _loc9_:ISystemManager = systemManager.topLevelSystemManager;
  851.          var _loc10_:DisplayObject = _loc9_.getSandboxRoot();
  852.          if(_loc9_ != _loc10_)
  853.          {
  854.             _loc12_ = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST,false,false,"getVisibleApplicationRect");
  855.             _loc10_.dispatchEvent(_loc12_);
  856.             _loc11_ = Rectangle(_loc12_.value);
  857.          }
  858.          else
  859.          {
  860.             _loc11_ = _loc9_.getVisibleApplicationRect();
  861.          }
  862.          if(param1)
  863.          {
  864.             _selectedIndexOnDropdown = selectedIndex;
  865.             getDropdown();
  866.             _dropdown.addEventListener(FlexMouseEvent.MOUSE_DOWN_OUTSIDE,dropdown_mouseOutsideHandler);
  867.             _dropdown.addEventListener(FlexMouseEvent.MOUSE_WHEEL_OUTSIDE,dropdown_mouseOutsideHandler);
  868.             _dropdown.addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,dropdown_mouseOutsideHandler);
  869.             _dropdown.addEventListener(SandboxMouseEvent.MOUSE_WHEEL_SOMEWHERE,dropdown_mouseOutsideHandler);
  870.             if(_dropdown.parent == null)
  871.             {
  872.                PopUpManager.addPopUp(_dropdown,this);
  873.             }
  874.             else
  875.             {
  876.                PopUpManager.bringToFront(_dropdown);
  877.             }
  878.             if(_loc8_.y + _dropdown.height > _loc11_.bottom && _loc8_.y > _loc11_.top + _dropdown.height)
  879.             {
  880.                _loc8_.y -= unscaledHeight + _dropdown.height;
  881.                _loc4_ = -_dropdown.height;
  882.                tweenUp = true;
  883.             }
  884.             else
  885.             {
  886.                _loc4_ = _dropdown.height;
  887.                tweenUp = false;
  888.             }
  889.             _loc8_ = _dropdown.parent.globalToLocal(_loc8_);
  890.             _loc13_ = _dropdown.selectedIndex;
  891.             if(_loc13_ == -1)
  892.             {
  893.                _loc13_ = 0;
  894.             }
  895.             _loc14_ = _dropdown.verticalScrollPosition;
  896.             _loc14_ = _loc13_ - 1;
  897.             _loc14_ = Math.min(Math.max(_loc14_,0),_dropdown.maxVerticalScrollPosition);
  898.             _dropdown.verticalScrollPosition = _loc14_;
  899.             if(_dropdown.x != _loc8_.x || _dropdown.y != _loc8_.y)
  900.             {
  901.                _dropdown.move(_loc8_.x,_loc8_.y);
  902.             }
  903.             _dropdown.scrollRect = new Rectangle(0,_loc4_,_dropdown.width,_dropdown.height);
  904.             if(!_dropdown.visible)
  905.             {
  906.                _dropdown.visible = true;
  907.             }
  908.             bRemoveDropdown = false;
  909.             _showingDropdown = param1;
  910.             _loc6_ = getStyle("openDuration");
  911.             _loc5_ = 0;
  912.             _loc7_ = getStyle("openEasingFunction") as Function;
  913.          }
  914.          else if(_dropdown)
  915.          {
  916.             _loc5_ = _loc8_.y + _dropdown.height > _loc11_.bottom || tweenUp ? -_dropdown.height : _dropdown.height;
  917.             _showingDropdown = param1;
  918.             _loc4_ = 0;
  919.             _loc6_ = getStyle("closeDuration");
  920.             _loc7_ = getStyle("closeEasingFunction") as Function;
  921.             _dropdown.mx_internal::resetDragScrolling();
  922.          }
  923.          inTween = true;
  924.          UIComponentGlobals.mx_internal::layoutManager.validateNow();
  925.          UIComponent.suspendBackgroundProcessing();
  926.          if(_dropdown)
  927.          {
  928.             _dropdown.enabled = false;
  929.          }
  930.          _loc6_ = Math.max(1,_loc6_);
  931.          if(!param3)
  932.          {
  933.             _loc6_ = 1;
  934.          }
  935.          tween = new Tween(this,_loc4_,_loc5_,_loc6_);
  936.          if(_loc7_ != null && Boolean(tween))
  937.          {
  938.             tween.easingFunction = _loc7_;
  939.          }
  940.          triggerEvent = param2;
  941.       }
  942.       
  943.       public function get itemRenderer() : IFactory
  944.       {
  945.          return _itemRenderer;
  946.       }
  947.       
  948.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  949.       {
  950.          super.updateDisplayList(param1,param2);
  951.          if(Boolean(_dropdown) && !inTween)
  952.          {
  953.             if(!_showingDropdown)
  954.             {
  955.                destroyDropdown();
  956.             }
  957.          }
  958.          else if(!_showingDropdown && inTween)
  959.          {
  960.             bRemoveDropdown = true;
  961.          }
  962.          var _loc3_:Number = preferredDropdownWidth;
  963.          if(isNaN(_loc3_))
  964.          {
  965.             _loc3_ = _dropdownWidth = param1;
  966.          }
  967.          if(labelFieldChanged)
  968.          {
  969.             if(_dropdown)
  970.             {
  971.                _dropdown.labelField = _labelField;
  972.             }
  973.             mx_internal::selectionChanged = true;
  974.             if(!explicitText)
  975.             {
  976.                textInput.text = selectedLabel;
  977.             }
  978.             labelFieldChanged = false;
  979.          }
  980.          if(labelFunctionChanged)
  981.          {
  982.             mx_internal::selectionChanged = true;
  983.             if(!explicitText)
  984.             {
  985.                textInput.text = selectedLabel;
  986.             }
  987.             labelFunctionChanged = false;
  988.          }
  989.          if(mx_internal::selectionChanged)
  990.          {
  991.             if(!mx_internal::textChanged)
  992.             {
  993.                if(selectedIndex == -1 && Boolean(prompt))
  994.                {
  995.                   textInput.text = prompt;
  996.                }
  997.                else if(!explicitText)
  998.                {
  999.                   textInput.text = selectedLabel;
  1000.                }
  1001.             }
  1002.             textInput.invalidateDisplayList();
  1003.             textInput.validateNow();
  1004.             if(editable)
  1005.             {
  1006.                textInput.mx_internal::getTextField().setSelection(0,textInput.text.length);
  1007.                textInput.mx_internal::getTextField().scrollH = 0;
  1008.             }
  1009.             if(_dropdown)
  1010.             {
  1011.                _dropdown.selectedIndex = selectedIndex;
  1012.             }
  1013.             mx_internal::selectionChanged = false;
  1014.          }
  1015.          if(Boolean(_dropdown) && _dropdown.rowCount != rowCount)
  1016.          {
  1017.             _dropdown.rowCount = rowCount;
  1018.          }
  1019.       }
  1020.       
  1021.       public function close(param1:Event = null) : void
  1022.       {
  1023.          if(_showingDropdown)
  1024.          {
  1025.             if(Boolean(_dropdown) && selectedIndex != _dropdown.selectedIndex)
  1026.             {
  1027.                selectedIndex = _dropdown.selectedIndex;
  1028.             }
  1029.             displayDropdown(false,param1);
  1030.             dispatchChangeEvent(new Event("dummy"),_selectedIndexOnDropdown,selectedIndex);
  1031.          }
  1032.       }
  1033.       
  1034.       public function set itemRenderer(param1:IFactory) : void
  1035.       {
  1036.          _itemRenderer = param1;
  1037.          if(_dropdown)
  1038.          {
  1039.             _dropdown.itemRenderer = param1;
  1040.          }
  1041.          invalidateSize();
  1042.          invalidateDisplayList();
  1043.          dispatchEvent(new Event("itemRendererChanged"));
  1044.       }
  1045.       
  1046.       override public function set showInAutomationHierarchy(param1:Boolean) : void
  1047.       {
  1048.       }
  1049.    }
  1050. }
  1051.  
  1052.