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