home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / Button.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  50.1 KB  |  1,528 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.events.TimerEvent;
  9.    import flash.text.TextLineMetrics;
  10.    import flash.ui.Keyboard;
  11.    import flash.utils.Timer;
  12.    import mx.controls.dataGridClasses.DataGridListData;
  13.    import mx.controls.listClasses.BaseListData;
  14.    import mx.controls.listClasses.IDropInListItemRenderer;
  15.    import mx.controls.listClasses.IListItemRenderer;
  16.    import mx.core.EdgeMetrics;
  17.    import mx.core.FlexVersion;
  18.    import mx.core.IBorder;
  19.    import mx.core.IButton;
  20.    import mx.core.IDataRenderer;
  21.    import mx.core.IFlexAsset;
  22.    import mx.core.IFlexDisplayObject;
  23.    import mx.core.IFlexModuleFactory;
  24.    import mx.core.IFontContextComponent;
  25.    import mx.core.IInvalidating;
  26.    import mx.core.IProgrammaticSkin;
  27.    import mx.core.IRectangularBorder;
  28.    import mx.core.IStateClient;
  29.    import mx.core.IUIComponent;
  30.    import mx.core.IUITextField;
  31.    import mx.core.UIComponent;
  32.    import mx.core.UITextField;
  33.    import mx.core.mx_internal;
  34.    import mx.events.FlexEvent;
  35.    import mx.events.MoveEvent;
  36.    import mx.events.SandboxMouseEvent;
  37.    import mx.managers.IFocusManagerComponent;
  38.    import mx.styles.ISimpleStyleClient;
  39.    
  40.    use namespace mx_internal;
  41.    
  42.    public class Button extends UIComponent implements IDataRenderer, IDropInListItemRenderer, IFocusManagerComponent, IListItemRenderer, IFontContextComponent, IButton
  43.    {
  44.       mx_internal static var createAccessibilityImplementation:Function;
  45.       
  46.       mx_internal static const VERSION:String = "3.5.0.12683";
  47.       
  48.       mx_internal static var TEXT_WIDTH_PADDING:Number = UITextField.mx_internal::TEXT_WIDTH_PADDING + 1;
  49.       
  50.       mx_internal var _emphasized:Boolean = false;
  51.       
  52.       mx_internal var extraSpacing:Number = 20;
  53.       
  54.       private var icons:Array = [];
  55.       
  56.       public var selectedField:String = null;
  57.       
  58.       private var labelChanged:Boolean = false;
  59.       
  60.       private var skinMeasuredWidth:Number;
  61.       
  62.       mx_internal var checkedDefaultSkin:Boolean = false;
  63.       
  64.       private var autoRepeatTimer:Timer;
  65.       
  66.       mx_internal var disabledIconName:String = "disabledIcon";
  67.       
  68.       mx_internal var disabledSkinName:String = "disabledSkin";
  69.       
  70.       mx_internal var checkedDefaultIcon:Boolean = false;
  71.       
  72.       public var stickyHighlighting:Boolean = false;
  73.       
  74.       private var enabledChanged:Boolean = false;
  75.       
  76.       mx_internal var selectedUpIconName:String = "selectedUpIcon";
  77.       
  78.       mx_internal var selectedUpSkinName:String = "selectedUpSkin";
  79.       
  80.       mx_internal var upIconName:String = "upIcon";
  81.       
  82.       mx_internal var upSkinName:String = "upSkin";
  83.       
  84.       mx_internal var centerContent:Boolean = true;
  85.       
  86.       mx_internal var buttonOffset:Number = 0;
  87.       
  88.       private var skinMeasuredHeight:Number;
  89.       
  90.       private var oldUnscaledWidth:Number;
  91.       
  92.       mx_internal var downIconName:String = "downIcon";
  93.       
  94.       mx_internal var _labelPlacement:String = "right";
  95.       
  96.       mx_internal var downSkinName:String = "downSkin";
  97.       
  98.       mx_internal var _toggle:Boolean = false;
  99.       
  100.       private var _phase:String = "up";
  101.       
  102.       private var toolTipSet:Boolean = false;
  103.       
  104.       private var _data:Object;
  105.       
  106.       mx_internal var currentIcon:IFlexDisplayObject;
  107.       
  108.       mx_internal var currentSkin:IFlexDisplayObject;
  109.       
  110.       mx_internal var overIconName:String = "overIcon";
  111.       
  112.       mx_internal var selectedDownIconName:String = "selectedDownIcon";
  113.       
  114.       mx_internal var overSkinName:String = "overSkin";
  115.       
  116.       mx_internal var iconName:String = "icon";
  117.       
  118.       mx_internal var skinName:String = "skin";
  119.       
  120.       mx_internal var selectedDownSkinName:String = "selectedDownSkin";
  121.       
  122.       private var skins:Array = [];
  123.       
  124.       private var selectedSet:Boolean;
  125.       
  126.       private var _autoRepeat:Boolean = false;
  127.       
  128.       private var styleChangedFlag:Boolean = true;
  129.       
  130.       mx_internal var selectedOverIconName:String = "selectedOverIcon";
  131.       
  132.       private var _listData:BaseListData;
  133.       
  134.       mx_internal var selectedOverSkinName:String = "selectedOverSkin";
  135.       
  136.       protected var textField:IUITextField;
  137.       
  138.       private var labelSet:Boolean;
  139.       
  140.       mx_internal var defaultIconUsesStates:Boolean = false;
  141.       
  142.       mx_internal var defaultSkinUsesStates:Boolean = false;
  143.       
  144.       mx_internal var toggleChanged:Boolean = false;
  145.       
  146.       private var emphasizedChanged:Boolean = false;
  147.       
  148.       private var _label:String = "";
  149.       
  150.       mx_internal var _selected:Boolean = false;
  151.       
  152.       mx_internal var selectedDisabledIconName:String = "selectedDisabledIcon";
  153.       
  154.       mx_internal var selectedDisabledSkinName:String = "selectedDisabledSkin";
  155.       
  156.       public function Button()
  157.       {
  158.          super();
  159.          mouseChildren = false;
  160.          addEventListener(MouseEvent.ROLL_OVER,rollOverHandler);
  161.          addEventListener(MouseEvent.ROLL_OUT,rollOutHandler);
  162.          addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  163.          addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler);
  164.          addEventListener(MouseEvent.CLICK,clickHandler);
  165.       }
  166.       
  167.       private function previousVersion_measure() : void
  168.       {
  169.          var iconHeight:Number;
  170.          var iconWidth:Number;
  171.          var textWidth:Number;
  172.          var tempCurrentIcon:IFlexDisplayObject;
  173.          var h:Number;
  174.          var textHeight:Number;
  175.          var w:Number;
  176.          var bm:EdgeMetrics = null;
  177.          var lineMetrics:TextLineMetrics = null;
  178.          var paddingLeft:Number = NaN;
  179.          var paddingRight:Number = NaN;
  180.          var paddingTop:Number = NaN;
  181.          var paddingBottom:Number = NaN;
  182.          var horizontalGap:Number = NaN;
  183.          super.measure();
  184.          textWidth = 0;
  185.          textHeight = 0;
  186.          if(label)
  187.          {
  188.             lineMetrics = measureText(label);
  189.             textWidth = lineMetrics.width;
  190.             textHeight = lineMetrics.height;
  191.             paddingLeft = getStyle("paddingLeft");
  192.             paddingRight = getStyle("paddingRight");
  193.             paddingTop = getStyle("paddingTop");
  194.             paddingBottom = getStyle("paddingBottom");
  195.             textWidth += paddingLeft + paddingRight + getStyle("textIndent");
  196.             textHeight += paddingTop + paddingBottom;
  197.          }
  198.          try
  199.          {
  200.             bm = mx_internal::currentSkin["borderMetrics"];
  201.          }
  202.          catch(e:Error)
  203.          {
  204.             bm = new EdgeMetrics(3,3,3,3);
  205.          }
  206.          tempCurrentIcon = mx_internal::getCurrentIcon();
  207.          iconWidth = !!tempCurrentIcon ? Number(tempCurrentIcon.width) : 0;
  208.          iconHeight = !!tempCurrentIcon ? Number(tempCurrentIcon.height) : 0;
  209.          w = 0;
  210.          h = 0;
  211.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  212.          {
  213.             w = textWidth + iconWidth;
  214.             if(iconWidth != 0)
  215.             {
  216.                horizontalGap = getStyle("horizontalGap");
  217.                w += horizontalGap - 2;
  218.             }
  219.             h = Math.max(textHeight,iconHeight + 6);
  220.          }
  221.          else
  222.          {
  223.             w = Math.max(textWidth,iconWidth);
  224.             h = textHeight + iconHeight;
  225.             if(iconHeight != 0)
  226.             {
  227.                h += getStyle("verticalGap");
  228.             }
  229.          }
  230.          if(bm)
  231.          {
  232.             w += bm.left + bm.right;
  233.             h += bm.top + bm.bottom;
  234.          }
  235.          if(Boolean(label) && label.length != 0)
  236.          {
  237.             w += mx_internal::extraSpacing;
  238.          }
  239.          else
  240.          {
  241.             w += 6;
  242.          }
  243.          if(Boolean(mx_internal::currentSkin) && (isNaN(skinMeasuredWidth) || isNaN(skinMeasuredHeight)))
  244.          {
  245.             skinMeasuredWidth = mx_internal::currentSkin.measuredWidth;
  246.             skinMeasuredHeight = mx_internal::currentSkin.measuredHeight;
  247.          }
  248.          if(!isNaN(skinMeasuredWidth))
  249.          {
  250.             w = Math.max(skinMeasuredWidth,w);
  251.          }
  252.          if(!isNaN(skinMeasuredHeight))
  253.          {
  254.             h = Math.max(skinMeasuredHeight,h);
  255.          }
  256.          measuredMinWidth = measuredWidth = w;
  257.          measuredMinHeight = measuredHeight = h;
  258.       }
  259.       
  260.       [Bindable("labelChanged")]
  261.       public function get label() : String
  262.       {
  263.          return _label;
  264.       }
  265.       
  266.       mx_internal function getCurrentIconName() : String
  267.       {
  268.          var _loc1_:String = null;
  269.          if(!enabled)
  270.          {
  271.             _loc1_ = selected ? mx_internal::selectedDisabledIconName : mx_internal::disabledIconName;
  272.          }
  273.          else if(mx_internal::phase == ButtonPhase.UP)
  274.          {
  275.             _loc1_ = selected ? mx_internal::selectedUpIconName : mx_internal::upIconName;
  276.          }
  277.          else if(mx_internal::phase == ButtonPhase.OVER)
  278.          {
  279.             _loc1_ = selected ? mx_internal::selectedOverIconName : mx_internal::overIconName;
  280.          }
  281.          else if(mx_internal::phase == ButtonPhase.DOWN)
  282.          {
  283.             _loc1_ = selected ? mx_internal::selectedDownIconName : mx_internal::downIconName;
  284.          }
  285.          return _loc1_;
  286.       }
  287.       
  288.       protected function mouseUpHandler(param1:MouseEvent) : void
  289.       {
  290.          if(!enabled)
  291.          {
  292.             return;
  293.          }
  294.          mx_internal::phase = ButtonPhase.OVER;
  295.          mx_internal::buttonReleased();
  296.          if(!toggle)
  297.          {
  298.             param1.updateAfterEvent();
  299.          }
  300.       }
  301.       
  302.       override protected function adjustFocusRect(param1:DisplayObject = null) : void
  303.       {
  304.          super.adjustFocusRect(!mx_internal::currentSkin ? DisplayObject(mx_internal::currentIcon) : this);
  305.       }
  306.       
  307.       mx_internal function set phase(param1:String) : void
  308.       {
  309.          _phase = param1;
  310.          invalidateSize();
  311.          invalidateDisplayList();
  312.       }
  313.       
  314.       mx_internal function viewIconForPhase(param1:String) : IFlexDisplayObject
  315.       {
  316.          var _loc3_:IFlexDisplayObject = null;
  317.          var _loc4_:Boolean = false;
  318.          var _loc5_:String = null;
  319.          var _loc2_:Class = Class(getStyle(param1));
  320.          if(!_loc2_)
  321.          {
  322.             _loc2_ = Class(getStyle(mx_internal::iconName));
  323.             if(mx_internal::defaultIconUsesStates)
  324.             {
  325.                param1 = mx_internal::iconName;
  326.             }
  327.             if(!mx_internal::checkedDefaultIcon && Boolean(_loc2_))
  328.             {
  329.                _loc3_ = IFlexDisplayObject(new _loc2_());
  330.                if(!(_loc3_ is IProgrammaticSkin) && _loc3_ is IStateClient)
  331.                {
  332.                   mx_internal::defaultIconUsesStates = true;
  333.                   param1 = mx_internal::iconName;
  334.                }
  335.                if(_loc3_)
  336.                {
  337.                   mx_internal::checkedDefaultIcon = true;
  338.                }
  339.             }
  340.          }
  341.          _loc3_ = IFlexDisplayObject(getChildByName(param1));
  342.          if(_loc3_ == null)
  343.          {
  344.             if(_loc2_ != null)
  345.             {
  346.                _loc3_ = IFlexDisplayObject(new _loc2_());
  347.                _loc3_.name = param1;
  348.                if(_loc3_ is ISimpleStyleClient)
  349.                {
  350.                   ISimpleStyleClient(_loc3_).styleName = this;
  351.                }
  352.                addChild(DisplayObject(_loc3_));
  353.                _loc4_ = false;
  354.                if(_loc3_ is IInvalidating)
  355.                {
  356.                   IInvalidating(_loc3_).validateNow();
  357.                   _loc4_ = true;
  358.                }
  359.                else if(_loc3_ is IProgrammaticSkin)
  360.                {
  361.                   IProgrammaticSkin(_loc3_).validateDisplayList();
  362.                   _loc4_ = true;
  363.                }
  364.                if(Boolean(_loc3_) && _loc3_ is IUIComponent)
  365.                {
  366.                   IUIComponent(_loc3_).enabled = enabled;
  367.                }
  368.                if(_loc4_)
  369.                {
  370.                   _loc3_.setActualSize(_loc3_.measuredWidth,_loc3_.measuredHeight);
  371.                }
  372.                icons.push(_loc3_);
  373.             }
  374.          }
  375.          if(mx_internal::currentIcon != null)
  376.          {
  377.             mx_internal::currentIcon.visible = false;
  378.          }
  379.          mx_internal::currentIcon = _loc3_;
  380.          if(mx_internal::defaultIconUsesStates && mx_internal::currentIcon is IStateClient)
  381.          {
  382.             _loc5_ = "";
  383.             if(!enabled)
  384.             {
  385.                _loc5_ = selected ? "selectedDisabled" : "disabled";
  386.             }
  387.             else if(mx_internal::phase == ButtonPhase.UP)
  388.             {
  389.                _loc5_ = selected ? "selectedUp" : "up";
  390.             }
  391.             else if(mx_internal::phase == ButtonPhase.OVER)
  392.             {
  393.                _loc5_ = selected ? "selectedOver" : "over";
  394.             }
  395.             else if(mx_internal::phase == ButtonPhase.DOWN)
  396.             {
  397.                _loc5_ = selected ? "selectedDown" : "down";
  398.             }
  399.             IStateClient(mx_internal::currentIcon).currentState = _loc5_;
  400.          }
  401.          if(mx_internal::currentIcon != null)
  402.          {
  403.             mx_internal::currentIcon.visible = true;
  404.          }
  405.          return _loc3_;
  406.       }
  407.       
  408.       mx_internal function viewSkinForPhase(param1:String, param2:String) : void
  409.       {
  410.          var _loc4_:IFlexDisplayObject = null;
  411.          var _loc5_:Number = NaN;
  412.          var _loc6_:ISimpleStyleClient = null;
  413.          var _loc3_:Class = Class(getStyle(param1));
  414.          if(!_loc3_)
  415.          {
  416.             _loc3_ = Class(getStyle(mx_internal::skinName));
  417.             if(mx_internal::defaultSkinUsesStates)
  418.             {
  419.                param1 = mx_internal::skinName;
  420.             }
  421.             if(!mx_internal::checkedDefaultSkin && Boolean(_loc3_))
  422.             {
  423.                _loc4_ = IFlexDisplayObject(new _loc3_());
  424.                if(!(_loc4_ is IProgrammaticSkin) && _loc4_ is IStateClient)
  425.                {
  426.                   mx_internal::defaultSkinUsesStates = true;
  427.                   param1 = mx_internal::skinName;
  428.                }
  429.                if(_loc4_)
  430.                {
  431.                   mx_internal::checkedDefaultSkin = true;
  432.                }
  433.             }
  434.          }
  435.          _loc4_ = IFlexDisplayObject(getChildByName(param1));
  436.          if(!_loc4_)
  437.          {
  438.             if(_loc3_)
  439.             {
  440.                _loc4_ = IFlexDisplayObject(new _loc3_());
  441.                _loc4_.name = param1;
  442.                _loc6_ = _loc4_ as ISimpleStyleClient;
  443.                if(_loc6_)
  444.                {
  445.                   _loc6_.styleName = this;
  446.                }
  447.                addChild(DisplayObject(_loc4_));
  448.                _loc4_.setActualSize(unscaledWidth,unscaledHeight);
  449.                if(_loc4_ is IInvalidating && initialized)
  450.                {
  451.                   IInvalidating(_loc4_).validateNow();
  452.                }
  453.                else if(_loc4_ is IProgrammaticSkin && initialized)
  454.                {
  455.                   IProgrammaticSkin(_loc4_).validateDisplayList();
  456.                }
  457.                skins.push(_loc4_);
  458.             }
  459.          }
  460.          if(mx_internal::currentSkin)
  461.          {
  462.             mx_internal::currentSkin.visible = false;
  463.          }
  464.          mx_internal::currentSkin = _loc4_;
  465.          if(mx_internal::defaultSkinUsesStates && mx_internal::currentSkin is IStateClient)
  466.          {
  467.             IStateClient(mx_internal::currentSkin).currentState = param2;
  468.          }
  469.          if(mx_internal::currentSkin)
  470.          {
  471.             mx_internal::currentSkin.visible = true;
  472.          }
  473.          if(enabled)
  474.          {
  475.             if(mx_internal::phase == ButtonPhase.OVER)
  476.             {
  477.                _loc5_ = textField.getStyle("textRollOverColor");
  478.             }
  479.             else if(mx_internal::phase == ButtonPhase.DOWN)
  480.             {
  481.                _loc5_ = textField.getStyle("textSelectedColor");
  482.             }
  483.             else
  484.             {
  485.                _loc5_ = textField.getStyle("color");
  486.             }
  487.             textField.setColor(_loc5_);
  488.          }
  489.       }
  490.       
  491.       mx_internal function getTextField() : IUITextField
  492.       {
  493.          return textField;
  494.       }
  495.       
  496.       protected function rollOverHandler(param1:MouseEvent) : void
  497.       {
  498.          if(mx_internal::phase == ButtonPhase.UP)
  499.          {
  500.             if(param1.buttonDown)
  501.             {
  502.                return;
  503.             }
  504.             mx_internal::phase = ButtonPhase.OVER;
  505.             param1.updateAfterEvent();
  506.          }
  507.          else if(mx_internal::phase == ButtonPhase.OVER)
  508.          {
  509.             mx_internal::phase = ButtonPhase.DOWN;
  510.             param1.updateAfterEvent();
  511.             if(autoRepeatTimer)
  512.             {
  513.                autoRepeatTimer.start();
  514.             }
  515.          }
  516.       }
  517.       
  518.       override protected function createChildren() : void
  519.       {
  520.          super.createChildren();
  521.          if(!textField)
  522.          {
  523.             textField = IUITextField(createInFontContext(UITextField));
  524.             textField.styleName = this;
  525.             addChild(DisplayObject(textField));
  526.          }
  527.       }
  528.       
  529.       mx_internal function setSelected(param1:Boolean, param2:Boolean = false) : void
  530.       {
  531.          if(mx_internal::_selected != param1)
  532.          {
  533.             mx_internal::_selected = param1;
  534.             invalidateDisplayList();
  535.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  536.             {
  537.                if(toggle)
  538.                {
  539.                   dispatchEvent(new Event(Event.CHANGE));
  540.                }
  541.             }
  542.             else if(toggle && !param2)
  543.             {
  544.                dispatchEvent(new Event(Event.CHANGE));
  545.             }
  546.             dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  547.          }
  548.       }
  549.       
  550.       private function autoRepeatTimer_timerDelayHandler(param1:Event) : void
  551.       {
  552.          if(!enabled)
  553.          {
  554.             return;
  555.          }
  556.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  557.          if(autoRepeat)
  558.          {
  559.             autoRepeatTimer.reset();
  560.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  561.             autoRepeatTimer.delay = getStyle("repeatInterval");
  562.             autoRepeatTimer.addEventListener(TimerEvent.TIMER,autoRepeatTimer_timerHandler);
  563.             autoRepeatTimer.start();
  564.          }
  565.       }
  566.       
  567.       public function get autoRepeat() : Boolean
  568.       {
  569.          return _autoRepeat;
  570.       }
  571.       
  572.       public function set selected(param1:Boolean) : void
  573.       {
  574.          selectedSet = true;
  575.          mx_internal::setSelected(param1,true);
  576.       }
  577.       
  578.       override protected function focusOutHandler(param1:FocusEvent) : void
  579.       {
  580.          super.focusOutHandler(param1);
  581.          if(mx_internal::phase != ButtonPhase.UP)
  582.          {
  583.             mx_internal::phase = ButtonPhase.UP;
  584.          }
  585.       }
  586.       
  587.       [Bindable("labelPlacementChanged")]
  588.       public function get labelPlacement() : String
  589.       {
  590.          return mx_internal::_labelPlacement;
  591.       }
  592.       
  593.       public function set autoRepeat(param1:Boolean) : void
  594.       {
  595.          _autoRepeat = param1;
  596.          if(param1)
  597.          {
  598.             autoRepeatTimer = new Timer(1);
  599.          }
  600.          else
  601.          {
  602.             autoRepeatTimer = null;
  603.          }
  604.       }
  605.       
  606.       mx_internal function changeIcons() : void
  607.       {
  608.          var _loc1_:int = int(icons.length);
  609.          var _loc2_:int = 0;
  610.          while(_loc2_ < _loc1_)
  611.          {
  612.             removeChild(icons[_loc2_]);
  613.             _loc2_++;
  614.          }
  615.          icons = [];
  616.          mx_internal::checkedDefaultIcon = false;
  617.          mx_internal::defaultIconUsesStates = false;
  618.       }
  619.       
  620.       public function set data(param1:Object) : void
  621.       {
  622.          var _loc2_:* = undefined;
  623.          var _loc3_:* = undefined;
  624.          _data = param1;
  625.          if(_listData && _listData is DataGridListData && DataGridListData(_listData).dataField != null)
  626.          {
  627.             _loc2_ = _data[DataGridListData(_listData).dataField];
  628.             _loc3_ = "";
  629.          }
  630.          else if(_listData)
  631.          {
  632.             if(selectedField)
  633.             {
  634.                _loc2_ = _data[selectedField];
  635.             }
  636.             _loc3_ = _listData.label;
  637.          }
  638.          else
  639.          {
  640.             _loc2_ = _data;
  641.          }
  642.          if(_loc2_ !== undefined && !selectedSet)
  643.          {
  644.             selected = _loc2_ as Boolean;
  645.             selectedSet = false;
  646.          }
  647.          if(_loc3_ !== undefined && !labelSet)
  648.          {
  649.             label = _loc3_;
  650.             labelSet = false;
  651.          }
  652.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  653.       }
  654.       
  655.       mx_internal function getCurrentIcon() : IFlexDisplayObject
  656.       {
  657.          var _loc1_:String = mx_internal::getCurrentIconName();
  658.          if(!_loc1_)
  659.          {
  660.             return null;
  661.          }
  662.          return mx_internal::viewIconForPhase(_loc1_);
  663.       }
  664.       
  665.       public function get fontContext() : IFlexModuleFactory
  666.       {
  667.          return moduleFactory;
  668.       }
  669.       
  670.       public function get emphasized() : Boolean
  671.       {
  672.          return mx_internal::_emphasized;
  673.       }
  674.       
  675.       [Bindable("dataChange")]
  676.       public function get listData() : BaseListData
  677.       {
  678.          return _listData;
  679.       }
  680.       
  681.       mx_internal function layoutContents(param1:Number, param2:Number, param3:Boolean) : void
  682.       {
  683.          var _loc20_:TextLineMetrics = null;
  684.          var _loc28_:MoveEvent = null;
  685.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  686.          {
  687.             previousVersion_layoutContents(param1,param2,param3);
  688.             return;
  689.          }
  690.          var _loc4_:Number = 0;
  691.          var _loc5_:Number = 0;
  692.          var _loc6_:Number = 0;
  693.          var _loc7_:Number = 0;
  694.          var _loc8_:Number = 0;
  695.          var _loc9_:Number = 0;
  696.          var _loc10_:Number = 0;
  697.          var _loc11_:Number = 0;
  698.          var _loc12_:Number = 0;
  699.          var _loc13_:Number = 0;
  700.          var _loc14_:Number = getStyle("paddingLeft");
  701.          var _loc15_:Number = getStyle("paddingRight");
  702.          var _loc16_:Number = getStyle("paddingTop");
  703.          var _loc17_:Number = getStyle("paddingBottom");
  704.          var _loc18_:Number = 0;
  705.          var _loc19_:Number = 0;
  706.          if(label)
  707.          {
  708.             _loc20_ = measureText(label);
  709.             _loc18_ = _loc20_.width + mx_internal::TEXT_WIDTH_PADDING;
  710.             _loc19_ = _loc20_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  711.          }
  712.          else
  713.          {
  714.             _loc20_ = measureText("Wj");
  715.             _loc19_ = _loc20_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  716.          }
  717.          var _loc21_:Number = param3 ? mx_internal::buttonOffset : 0;
  718.          var _loc22_:String = getStyle("textAlign");
  719.          var _loc23_:Number = param1;
  720.          var _loc24_:Number = param2;
  721.          var _loc25_:EdgeMetrics = mx_internal::currentSkin && mx_internal::currentSkin is IBorder && !(mx_internal::currentSkin is IFlexAsset) ? IBorder(mx_internal::currentSkin).borderMetrics : null;
  722.          if(_loc25_)
  723.          {
  724.             _loc23_ -= _loc25_.left + _loc25_.right;
  725.             _loc24_ -= _loc25_.top + _loc25_.bottom;
  726.          }
  727.          if(mx_internal::currentIcon)
  728.          {
  729.             _loc8_ = Number(mx_internal::currentIcon.width);
  730.             _loc9_ = Number(mx_internal::currentIcon.height);
  731.          }
  732.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  733.          {
  734.             _loc12_ = getStyle("horizontalGap");
  735.             if(_loc8_ == 0 || _loc18_ == 0)
  736.             {
  737.                _loc12_ = 0;
  738.             }
  739.             if(_loc18_ > 0)
  740.             {
  741.                textField.width = _loc4_ = Math.max(Math.min(_loc23_ - _loc8_ - _loc12_ - _loc14_ - _loc15_,_loc18_),0);
  742.             }
  743.             else
  744.             {
  745.                textField.width = _loc4_ = 0;
  746.             }
  747.             textField.height = _loc5_ = Math.min(_loc24_,_loc19_);
  748.             if(_loc22_ == "left")
  749.             {
  750.                _loc6_ += _loc14_;
  751.             }
  752.             else if(_loc22_ == "right")
  753.             {
  754.                _loc6_ += _loc23_ - _loc4_ - _loc8_ - _loc12_ - _loc15_;
  755.             }
  756.             else
  757.             {
  758.                _loc6_ += (_loc23_ - _loc4_ - _loc8_ - _loc12_ - _loc14_ - _loc15_) / 2 + _loc14_;
  759.             }
  760.             if(labelPlacement == ButtonLabelPlacement.RIGHT)
  761.             {
  762.                _loc6_ += _loc8_ + _loc12_;
  763.                _loc10_ = _loc6_ - (_loc8_ + _loc12_);
  764.             }
  765.             else
  766.             {
  767.                _loc10_ = _loc6_ + _loc4_ + _loc12_;
  768.             }
  769.             _loc11_ = (_loc24_ - _loc9_ - _loc16_ - _loc17_) / 2 + _loc16_;
  770.             _loc7_ = (_loc24_ - _loc5_ - _loc16_ - _loc17_) / 2 + _loc16_;
  771.          }
  772.          else
  773.          {
  774.             _loc13_ = getStyle("verticalGap");
  775.             if(_loc9_ == 0 || label == "")
  776.             {
  777.                _loc13_ = 0;
  778.             }
  779.             if(_loc18_ > 0)
  780.             {
  781.                textField.width = _loc4_ = Math.max(_loc23_ - _loc14_ - _loc15_,0);
  782.                textField.height = _loc5_ = Math.min(_loc24_ - _loc9_ - _loc16_ - _loc17_ - _loc13_,_loc19_);
  783.             }
  784.             else
  785.             {
  786.                textField.width = _loc4_ = 0;
  787.                textField.height = _loc5_ = 0;
  788.             }
  789.             _loc6_ = _loc14_;
  790.             if(_loc22_ == "left")
  791.             {
  792.                _loc10_ += _loc14_;
  793.             }
  794.             else if(_loc22_ == "right")
  795.             {
  796.                _loc10_ += Math.max(_loc23_ - _loc8_ - _loc15_,_loc14_);
  797.             }
  798.             else
  799.             {
  800.                _loc10_ += (_loc23_ - _loc8_ - _loc14_ - _loc15_) / 2 + _loc14_;
  801.             }
  802.             if(labelPlacement == ButtonLabelPlacement.TOP)
  803.             {
  804.                _loc7_ += (_loc24_ - _loc5_ - _loc9_ - _loc16_ - _loc17_ - _loc13_) / 2 + _loc16_;
  805.                _loc11_ += _loc7_ + _loc5_ + _loc13_;
  806.             }
  807.             else
  808.             {
  809.                _loc11_ += (_loc24_ - _loc5_ - _loc9_ - _loc16_ - _loc17_ - _loc13_) / 2 + _loc16_;
  810.                _loc7_ += _loc11_ + _loc9_ + _loc13_;
  811.             }
  812.          }
  813.          var _loc26_:Number = _loc21_;
  814.          var _loc27_:Number = _loc21_;
  815.          if(_loc25_)
  816.          {
  817.             _loc26_ += _loc25_.left;
  818.             _loc27_ += _loc25_.top;
  819.          }
  820.          textField.x = Math.round(_loc6_ + _loc26_);
  821.          textField.y = Math.round(_loc7_ + _loc27_);
  822.          if(mx_internal::currentIcon)
  823.          {
  824.             _loc10_ += _loc26_;
  825.             _loc11_ += _loc27_;
  826.             _loc28_ = new MoveEvent(MoveEvent.MOVE);
  827.             _loc28_.oldX = mx_internal::currentIcon.x;
  828.             _loc28_.oldY = mx_internal::currentIcon.y;
  829.             mx_internal::currentIcon.x = Math.round(_loc10_);
  830.             mx_internal::currentIcon.y = Math.round(_loc11_);
  831.             mx_internal::currentIcon.dispatchEvent(_loc28_);
  832.          }
  833.          if(mx_internal::currentSkin)
  834.          {
  835.             setChildIndex(DisplayObject(mx_internal::currentSkin),numChildren - 1);
  836.          }
  837.          if(mx_internal::currentIcon)
  838.          {
  839.             setChildIndex(DisplayObject(mx_internal::currentIcon),numChildren - 1);
  840.          }
  841.          if(textField)
  842.          {
  843.             setChildIndex(DisplayObject(textField),numChildren - 1);
  844.          }
  845.       }
  846.       
  847.       protected function mouseDownHandler(param1:MouseEvent) : void
  848.       {
  849.          if(!enabled)
  850.          {
  851.             return;
  852.          }
  853.          systemManager.getSandboxRoot().addEventListener(MouseEvent.MOUSE_UP,systemManager_mouseUpHandler,true);
  854.          systemManager.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,stage_mouseLeaveHandler);
  855.          mx_internal::buttonPressed();
  856.          param1.updateAfterEvent();
  857.       }
  858.       
  859.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  860.       {
  861.          if(!enabled)
  862.          {
  863.             return;
  864.          }
  865.          if(param1.keyCode == Keyboard.SPACE)
  866.          {
  867.             mx_internal::buttonPressed();
  868.          }
  869.       }
  870.       
  871.       protected function rollOutHandler(param1:MouseEvent) : void
  872.       {
  873.          if(mx_internal::phase == ButtonPhase.OVER)
  874.          {
  875.             mx_internal::phase = ButtonPhase.UP;
  876.             param1.updateAfterEvent();
  877.          }
  878.          else if(mx_internal::phase == ButtonPhase.DOWN && !stickyHighlighting)
  879.          {
  880.             mx_internal::phase = ButtonPhase.OVER;
  881.             param1.updateAfterEvent();
  882.             if(autoRepeatTimer)
  883.             {
  884.                autoRepeatTimer.stop();
  885.             }
  886.          }
  887.       }
  888.       
  889.       mx_internal function get phase() : String
  890.       {
  891.          return _phase;
  892.       }
  893.       
  894.       override public function set enabled(param1:Boolean) : void
  895.       {
  896.          if(super.enabled == param1)
  897.          {
  898.             return;
  899.          }
  900.          super.enabled = param1;
  901.          enabledChanged = true;
  902.          invalidateProperties();
  903.          invalidateDisplayList();
  904.       }
  905.       
  906.       override protected function measure() : void
  907.       {
  908.          var _loc9_:TextLineMetrics = null;
  909.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  910.          {
  911.             previousVersion_measure();
  912.             return;
  913.          }
  914.          super.measure();
  915.          var _loc1_:Number = 0;
  916.          var _loc2_:Number = 0;
  917.          if(label)
  918.          {
  919.             _loc9_ = measureText(label);
  920.             _loc1_ = _loc9_.width + mx_internal::TEXT_WIDTH_PADDING;
  921.             _loc2_ = _loc9_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  922.          }
  923.          var _loc3_:IFlexDisplayObject = mx_internal::getCurrentIcon();
  924.          var _loc4_:Number = !!_loc3_ ? Number(_loc3_.width) : 0;
  925.          var _loc5_:Number = !!_loc3_ ? Number(_loc3_.height) : 0;
  926.          var _loc6_:Number = 0;
  927.          var _loc7_:Number = 0;
  928.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  929.          {
  930.             _loc6_ = _loc1_ + _loc4_;
  931.             if(Boolean(_loc1_) && Boolean(_loc4_))
  932.             {
  933.                _loc6_ += getStyle("horizontalGap");
  934.             }
  935.             _loc7_ = Math.max(_loc2_,_loc5_);
  936.          }
  937.          else
  938.          {
  939.             _loc6_ = Math.max(_loc1_,_loc4_);
  940.             _loc7_ = _loc2_ + _loc5_;
  941.             if(Boolean(_loc2_) && Boolean(_loc5_))
  942.             {
  943.                _loc7_ += getStyle("verticalGap");
  944.             }
  945.          }
  946.          if(Boolean(_loc1_) || Boolean(_loc4_))
  947.          {
  948.             _loc6_ += getStyle("paddingLeft") + getStyle("paddingRight");
  949.             _loc7_ += getStyle("paddingTop") + getStyle("paddingBottom");
  950.          }
  951.          var _loc8_:EdgeMetrics = mx_internal::currentSkin && mx_internal::currentSkin is IBorder && !(mx_internal::currentSkin is IFlexAsset) ? IBorder(mx_internal::currentSkin).borderMetrics : null;
  952.          if(_loc8_)
  953.          {
  954.             _loc6_ += _loc8_.left + _loc8_.right;
  955.             _loc7_ += _loc8_.top + _loc8_.bottom;
  956.          }
  957.          if(Boolean(mx_internal::currentSkin) && (isNaN(skinMeasuredWidth) || isNaN(skinMeasuredHeight)))
  958.          {
  959.             skinMeasuredWidth = mx_internal::currentSkin.measuredWidth;
  960.             skinMeasuredHeight = mx_internal::currentSkin.measuredHeight;
  961.          }
  962.          if(!isNaN(skinMeasuredWidth))
  963.          {
  964.             _loc6_ = Math.max(skinMeasuredWidth,_loc6_);
  965.          }
  966.          if(!isNaN(skinMeasuredHeight))
  967.          {
  968.             _loc7_ = Math.max(skinMeasuredHeight,_loc7_);
  969.          }
  970.          measuredMinWidth = measuredWidth = _loc6_;
  971.          measuredMinHeight = measuredHeight = _loc7_;
  972.       }
  973.       
  974.       [Bindable("toggleChanged")]
  975.       public function get toggle() : Boolean
  976.       {
  977.          return mx_internal::_toggle;
  978.       }
  979.       
  980.       mx_internal function buttonReleased() : void
  981.       {
  982.          systemManager.getSandboxRoot().removeEventListener(MouseEvent.MOUSE_UP,systemManager_mouseUpHandler,true);
  983.          systemManager.getSandboxRoot().removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,stage_mouseLeaveHandler);
  984.          if(autoRepeatTimer)
  985.          {
  986.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  987.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerHandler);
  988.             autoRepeatTimer.reset();
  989.          }
  990.       }
  991.       
  992.       mx_internal function buttonPressed() : void
  993.       {
  994.          mx_internal::phase = ButtonPhase.DOWN;
  995.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  996.          if(autoRepeat)
  997.          {
  998.             autoRepeatTimer.delay = getStyle("repeatDelay");
  999.             autoRepeatTimer.addEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  1000.             autoRepeatTimer.start();
  1001.          }
  1002.       }
  1003.       
  1004.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  1005.       {
  1006.          if(!enabled)
  1007.          {
  1008.             return;
  1009.          }
  1010.          if(param1.keyCode == Keyboard.SPACE)
  1011.          {
  1012.             mx_internal::buttonReleased();
  1013.             if(mx_internal::phase == ButtonPhase.DOWN)
  1014.             {
  1015.                dispatchEvent(new MouseEvent(MouseEvent.CLICK));
  1016.             }
  1017.             mx_internal::phase = ButtonPhase.UP;
  1018.          }
  1019.       }
  1020.       
  1021.       [Bindable("valueCommit")]
  1022.       [Bindable("click")]
  1023.       public function get selected() : Boolean
  1024.       {
  1025.          return mx_internal::_selected;
  1026.       }
  1027.       
  1028.       public function set labelPlacement(param1:String) : void
  1029.       {
  1030.          mx_internal::_labelPlacement = param1;
  1031.          invalidateSize();
  1032.          invalidateDisplayList();
  1033.          dispatchEvent(new Event("labelPlacementChanged"));
  1034.       }
  1035.       
  1036.       protected function clickHandler(param1:MouseEvent) : void
  1037.       {
  1038.          if(!enabled)
  1039.          {
  1040.             param1.stopImmediatePropagation();
  1041.             return;
  1042.          }
  1043.          if(toggle)
  1044.          {
  1045.             mx_internal::setSelected(!selected);
  1046.             param1.updateAfterEvent();
  1047.          }
  1048.       }
  1049.       
  1050.       override protected function initializeAccessibility() : void
  1051.       {
  1052.          if(Button.mx_internal::createAccessibilityImplementation != null)
  1053.          {
  1054.             Button.mx_internal::createAccessibilityImplementation(this);
  1055.          }
  1056.       }
  1057.       
  1058.       public function set toggle(param1:Boolean) : void
  1059.       {
  1060.          mx_internal::_toggle = param1;
  1061.          mx_internal::toggleChanged = true;
  1062.          invalidateProperties();
  1063.          invalidateDisplayList();
  1064.          dispatchEvent(new Event("toggleChanged"));
  1065.       }
  1066.       
  1067.       override public function get baselinePosition() : Number
  1068.       {
  1069.          var _loc1_:String = null;
  1070.          var _loc2_:TextLineMetrics = null;
  1071.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  1072.          {
  1073.             _loc1_ = label;
  1074.             if(!_loc1_)
  1075.             {
  1076.                _loc1_ = "Wj";
  1077.             }
  1078.             validateNow();
  1079.             if(!label && (labelPlacement == ButtonLabelPlacement.TOP || labelPlacement == ButtonLabelPlacement.BOTTOM))
  1080.             {
  1081.                _loc2_ = measureText(_loc1_);
  1082.                return (measuredHeight - _loc2_.height) / 2 + _loc2_.ascent;
  1083.             }
  1084.             return textField.y + measureText(_loc1_).ascent;
  1085.          }
  1086.          if(!mx_internal::validateBaselinePosition())
  1087.          {
  1088.             return NaN;
  1089.          }
  1090.          return textField.y + textField.baselinePosition;
  1091.       }
  1092.       
  1093.       [Bindable("dataChange")]
  1094.       public function get data() : Object
  1095.       {
  1096.          return _data;
  1097.       }
  1098.       
  1099.       public function set fontContext(param1:IFlexModuleFactory) : void
  1100.       {
  1101.          this.moduleFactory = param1;
  1102.       }
  1103.       
  1104.       mx_internal function viewSkin() : void
  1105.       {
  1106.          var _loc1_:String = null;
  1107.          var _loc2_:String = null;
  1108.          if(!enabled)
  1109.          {
  1110.             _loc1_ = selected ? mx_internal::selectedDisabledSkinName : mx_internal::disabledSkinName;
  1111.             _loc2_ = selected ? "selectedDisabled" : "disabled";
  1112.          }
  1113.          else if(mx_internal::phase == ButtonPhase.UP)
  1114.          {
  1115.             _loc1_ = selected ? mx_internal::selectedUpSkinName : mx_internal::upSkinName;
  1116.             _loc2_ = selected ? "selectedUp" : "up";
  1117.          }
  1118.          else if(mx_internal::phase == ButtonPhase.OVER)
  1119.          {
  1120.             _loc1_ = selected ? mx_internal::selectedOverSkinName : mx_internal::overSkinName;
  1121.             _loc2_ = selected ? "selectedOver" : "over";
  1122.          }
  1123.          else if(mx_internal::phase == ButtonPhase.DOWN)
  1124.          {
  1125.             _loc1_ = selected ? mx_internal::selectedDownSkinName : mx_internal::downSkinName;
  1126.             _loc2_ = selected ? "selectedDown" : "down";
  1127.          }
  1128.          mx_internal::viewSkinForPhase(_loc1_,_loc2_);
  1129.       }
  1130.       
  1131.       override public function styleChanged(param1:String) : void
  1132.       {
  1133.          styleChangedFlag = true;
  1134.          super.styleChanged(param1);
  1135.          if(!param1 || param1 == "styleName")
  1136.          {
  1137.             mx_internal::changeSkins();
  1138.             mx_internal::changeIcons();
  1139.             if(initialized)
  1140.             {
  1141.                mx_internal::viewSkin();
  1142.                mx_internal::viewIcon();
  1143.             }
  1144.          }
  1145.          else if(param1.toLowerCase().indexOf("skin") != -1)
  1146.          {
  1147.             mx_internal::changeSkins();
  1148.          }
  1149.          else if(param1.toLowerCase().indexOf("icon") != -1)
  1150.          {
  1151.             mx_internal::changeIcons();
  1152.             invalidateSize();
  1153.          }
  1154.       }
  1155.       
  1156.       public function set emphasized(param1:Boolean) : void
  1157.       {
  1158.          mx_internal::_emphasized = param1;
  1159.          emphasizedChanged = true;
  1160.          invalidateDisplayList();
  1161.       }
  1162.       
  1163.       mx_internal function viewIcon() : void
  1164.       {
  1165.          var _loc1_:String = mx_internal::getCurrentIconName();
  1166.          mx_internal::viewIconForPhase(_loc1_);
  1167.       }
  1168.       
  1169.       override public function set toolTip(param1:String) : void
  1170.       {
  1171.          super.toolTip = param1;
  1172.          if(param1)
  1173.          {
  1174.             toolTipSet = true;
  1175.          }
  1176.          else
  1177.          {
  1178.             toolTipSet = false;
  1179.             invalidateDisplayList();
  1180.          }
  1181.       }
  1182.       
  1183.       override protected function commitProperties() : void
  1184.       {
  1185.          super.commitProperties();
  1186.          if(hasFontContextChanged() && textField != null)
  1187.          {
  1188.             removeChild(DisplayObject(textField));
  1189.             textField = null;
  1190.          }
  1191.          if(!textField)
  1192.          {
  1193.             textField = IUITextField(createInFontContext(UITextField));
  1194.             textField.styleName = this;
  1195.             addChild(DisplayObject(textField));
  1196.             enabledChanged = true;
  1197.             mx_internal::toggleChanged = true;
  1198.          }
  1199.          if(!initialized)
  1200.          {
  1201.             mx_internal::viewSkin();
  1202.             mx_internal::viewIcon();
  1203.          }
  1204.          if(enabledChanged)
  1205.          {
  1206.             textField.enabled = enabled;
  1207.             if(Boolean(mx_internal::currentIcon) && mx_internal::currentIcon is IUIComponent)
  1208.             {
  1209.                IUIComponent(mx_internal::currentIcon).enabled = enabled;
  1210.             }
  1211.             enabledChanged = false;
  1212.          }
  1213.          if(mx_internal::toggleChanged)
  1214.          {
  1215.             if(!toggle)
  1216.             {
  1217.                selected = false;
  1218.             }
  1219.             mx_internal::toggleChanged = false;
  1220.          }
  1221.       }
  1222.       
  1223.       mx_internal function changeSkins() : void
  1224.       {
  1225.          var _loc1_:int = int(skins.length);
  1226.          var _loc2_:int = 0;
  1227.          while(_loc2_ < _loc1_)
  1228.          {
  1229.             removeChild(skins[_loc2_]);
  1230.             _loc2_++;
  1231.          }
  1232.          skins = [];
  1233.          skinMeasuredWidth = NaN;
  1234.          skinMeasuredHeight = NaN;
  1235.          mx_internal::checkedDefaultSkin = false;
  1236.          mx_internal::defaultSkinUsesStates = false;
  1237.          if(initialized && FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  1238.          {
  1239.             mx_internal::viewSkin();
  1240.             invalidateSize();
  1241.          }
  1242.       }
  1243.       
  1244.       private function autoRepeatTimer_timerHandler(param1:Event) : void
  1245.       {
  1246.          if(!enabled)
  1247.          {
  1248.             return;
  1249.          }
  1250.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  1251.       }
  1252.       
  1253.       private function previousVersion_layoutContents(param1:Number, param2:Number, param3:Boolean) : void
  1254.       {
  1255.          var _loc20_:TextLineMetrics = null;
  1256.          var _loc28_:Number = NaN;
  1257.          var _loc29_:MoveEvent = null;
  1258.          var _loc4_:Number = 0;
  1259.          var _loc5_:Number = 0;
  1260.          var _loc6_:Number = 0;
  1261.          var _loc7_:Number = 0;
  1262.          var _loc8_:Number = 0;
  1263.          var _loc9_:Number = 0;
  1264.          var _loc10_:Number = 0;
  1265.          var _loc11_:Number = 0;
  1266.          var _loc12_:Number = 2;
  1267.          var _loc13_:Number = 2;
  1268.          var _loc14_:Number = getStyle("paddingLeft");
  1269.          var _loc15_:Number = getStyle("paddingRight");
  1270.          var _loc16_:Number = getStyle("paddingTop");
  1271.          var _loc17_:Number = getStyle("paddingBottom");
  1272.          var _loc18_:Number = 0;
  1273.          var _loc19_:Number = 0;
  1274.          if(label)
  1275.          {
  1276.             _loc20_ = measureText(label);
  1277.             if(_loc20_.width > 0)
  1278.             {
  1279.                _loc18_ = _loc14_ + _loc15_ + getStyle("textIndent") + _loc20_.width;
  1280.             }
  1281.             _loc19_ = _loc20_.height;
  1282.          }
  1283.          else
  1284.          {
  1285.             _loc20_ = measureText("Wj");
  1286.             _loc19_ = _loc20_.height;
  1287.          }
  1288.          var _loc21_:Number = param3 ? mx_internal::buttonOffset : 0;
  1289.          var _loc22_:String = getStyle("textAlign");
  1290.          var _loc23_:EdgeMetrics = Boolean(mx_internal::currentSkin) && mx_internal::currentSkin is IRectangularBorder ? IRectangularBorder(mx_internal::currentSkin).borderMetrics : null;
  1291.          var _loc24_:Number = param1;
  1292.          var _loc25_:Number = param2 - _loc16_ - _loc17_;
  1293.          if(_loc23_)
  1294.          {
  1295.             _loc24_ -= _loc23_.left + _loc23_.right;
  1296.             _loc25_ -= _loc23_.top + _loc23_.bottom;
  1297.          }
  1298.          if(mx_internal::currentIcon)
  1299.          {
  1300.             _loc8_ = Number(mx_internal::currentIcon.width);
  1301.             _loc9_ = Number(mx_internal::currentIcon.height);
  1302.          }
  1303.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  1304.          {
  1305.             _loc12_ = getStyle("horizontalGap");
  1306.             if(_loc8_ == 0 || _loc18_ == 0)
  1307.             {
  1308.                _loc12_ = 0;
  1309.             }
  1310.             if(_loc18_ > 0)
  1311.             {
  1312.                textField.width = _loc4_ = Math.max(_loc24_ - _loc8_ - _loc12_ - _loc14_ - _loc15_,0);
  1313.             }
  1314.             else
  1315.             {
  1316.                textField.width = _loc4_ = 0;
  1317.             }
  1318.             textField.height = _loc5_ = Math.min(_loc25_ + 2,_loc19_ + UITextField.mx_internal::TEXT_HEIGHT_PADDING);
  1319.             if(labelPlacement == ButtonLabelPlacement.RIGHT)
  1320.             {
  1321.                _loc6_ = _loc8_ + _loc12_;
  1322.                if(mx_internal::centerContent)
  1323.                {
  1324.                   if(_loc22_ == "left")
  1325.                   {
  1326.                      _loc6_ += _loc14_;
  1327.                   }
  1328.                   else if(_loc22_ == "right")
  1329.                   {
  1330.                      _loc6_ += _loc24_ - _loc4_ - _loc8_ - _loc12_ - _loc14_;
  1331.                   }
  1332.                   else
  1333.                   {
  1334.                      _loc28_ = (_loc24_ - _loc4_ - _loc8_ - _loc12_) / 2;
  1335.                      _loc6_ += Math.max(_loc28_,_loc14_);
  1336.                   }
  1337.                }
  1338.                _loc10_ = _loc6_ - (_loc8_ + _loc12_);
  1339.                if(!mx_internal::centerContent)
  1340.                {
  1341.                   _loc6_ += _loc14_;
  1342.                }
  1343.             }
  1344.             else
  1345.             {
  1346.                _loc6_ = _loc24_ - _loc4_ - _loc8_ - _loc12_ - _loc15_;
  1347.                if(mx_internal::centerContent)
  1348.                {
  1349.                   if(_loc22_ == "left")
  1350.                   {
  1351.                      _loc6_ = 2;
  1352.                   }
  1353.                   else if(_loc22_ == "right")
  1354.                   {
  1355.                      _loc6_--;
  1356.                   }
  1357.                   else if(_loc6_ > 0)
  1358.                   {
  1359.                      _loc6_ /= 2;
  1360.                   }
  1361.                }
  1362.                _loc10_ = _loc6_ + _loc4_ + _loc12_;
  1363.             }
  1364.             _loc11_ = _loc7_ = 0;
  1365.             if(mx_internal::centerContent)
  1366.             {
  1367.                _loc11_ = Math.round((_loc25_ - _loc9_) / 2) + _loc16_;
  1368.                _loc7_ = Math.round((_loc25_ - _loc5_) / 2) + _loc16_;
  1369.             }
  1370.             else
  1371.             {
  1372.                _loc7_ += Math.max(0,(_loc25_ - _loc5_) / 2) + _loc16_;
  1373.                _loc11_ += Math.max(0,(_loc25_ - _loc9_) / 2 - 1) + _loc16_;
  1374.             }
  1375.          }
  1376.          else
  1377.          {
  1378.             _loc13_ = getStyle("verticalGap");
  1379.             if(_loc9_ == 0 || _loc19_ == 0)
  1380.             {
  1381.                _loc13_ = 0;
  1382.             }
  1383.             if(_loc18_ > 0)
  1384.             {
  1385.                textField.width = _loc4_ = Math.min(_loc24_,_loc18_ + UITextField.mx_internal::TEXT_WIDTH_PADDING);
  1386.                textField.height = _loc5_ = Math.min(_loc25_ - _loc9_ + 1,_loc19_ + 5);
  1387.             }
  1388.             else
  1389.             {
  1390.                textField.width = _loc4_ = 0;
  1391.                textField.height = _loc5_ = 0;
  1392.             }
  1393.             _loc6_ = (_loc24_ - _loc4_) / 2;
  1394.             _loc10_ = (_loc24_ - _loc8_) / 2;
  1395.             if(labelPlacement == ButtonLabelPlacement.TOP)
  1396.             {
  1397.                _loc7_ = _loc25_ - _loc5_ - _loc9_ - _loc13_;
  1398.                if(mx_internal::centerContent && _loc7_ > 0)
  1399.                {
  1400.                   _loc7_ /= 2;
  1401.                }
  1402.                _loc7_ += _loc16_;
  1403.                _loc11_ = _loc7_ + _loc5_ + _loc13_ - 3;
  1404.             }
  1405.             else
  1406.             {
  1407.                _loc7_ = _loc9_ + _loc13_ + _loc16_;
  1408.                if(mx_internal::centerContent)
  1409.                {
  1410.                   _loc7_ += (_loc25_ - _loc5_ - _loc9_ - _loc13_) / 2 + 1;
  1411.                }
  1412.                _loc11_ = _loc7_ - _loc9_ - _loc13_ + 3;
  1413.             }
  1414.          }
  1415.          var _loc26_:Number = _loc21_;
  1416.          var _loc27_:Number = _loc21_;
  1417.          if(_loc23_)
  1418.          {
  1419.             _loc26_ += _loc23_.left;
  1420.             _loc27_ += _loc23_.top;
  1421.          }
  1422.          textField.x = _loc6_ + _loc26_;
  1423.          textField.y = _loc7_ + _loc27_;
  1424.          if(mx_internal::currentIcon)
  1425.          {
  1426.             _loc10_ += _loc26_;
  1427.             _loc11_ += _loc27_;
  1428.             _loc29_ = new MoveEvent(MoveEvent.MOVE);
  1429.             _loc29_.oldX = mx_internal::currentIcon.x;
  1430.             _loc29_.oldY = mx_internal::currentIcon.y;
  1431.             mx_internal::currentIcon.x = Math.round(_loc10_);
  1432.             mx_internal::currentIcon.y = Math.round(_loc11_);
  1433.             mx_internal::currentIcon.dispatchEvent(_loc29_);
  1434.          }
  1435.          if(mx_internal::currentSkin)
  1436.          {
  1437.             setChildIndex(DisplayObject(mx_internal::currentSkin),numChildren - 1);
  1438.          }
  1439.          if(mx_internal::currentIcon)
  1440.          {
  1441.             setChildIndex(DisplayObject(mx_internal::currentIcon),numChildren - 1);
  1442.          }
  1443.          if(textField)
  1444.          {
  1445.             setChildIndex(DisplayObject(textField),numChildren - 1);
  1446.          }
  1447.       }
  1448.       
  1449.       private function systemManager_mouseUpHandler(param1:MouseEvent) : void
  1450.       {
  1451.          if(contains(DisplayObject(param1.target)))
  1452.          {
  1453.             return;
  1454.          }
  1455.          mx_internal::phase = ButtonPhase.UP;
  1456.          mx_internal::buttonReleased();
  1457.          param1.updateAfterEvent();
  1458.       }
  1459.       
  1460.       public function set label(param1:String) : void
  1461.       {
  1462.          labelSet = true;
  1463.          if(_label != param1)
  1464.          {
  1465.             _label = param1;
  1466.             labelChanged = true;
  1467.             invalidateSize();
  1468.             invalidateDisplayList();
  1469.             dispatchEvent(new Event("labelChanged"));
  1470.          }
  1471.       }
  1472.       
  1473.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1474.       {
  1475.          var _loc5_:IFlexDisplayObject = null;
  1476.          var _loc6_:Boolean = false;
  1477.          super.updateDisplayList(param1,param2);
  1478.          if(emphasizedChanged)
  1479.          {
  1480.             mx_internal::changeSkins();
  1481.             emphasizedChanged = false;
  1482.          }
  1483.          var _loc3_:int = int(skins.length);
  1484.          var _loc4_:int = 0;
  1485.          while(_loc4_ < _loc3_)
  1486.          {
  1487.             _loc5_ = IFlexDisplayObject(skins[_loc4_]);
  1488.             _loc5_.setActualSize(param1,param2);
  1489.             _loc4_++;
  1490.          }
  1491.          mx_internal::viewSkin();
  1492.          mx_internal::viewIcon();
  1493.          mx_internal::layoutContents(param1,param2,mx_internal::phase == ButtonPhase.DOWN);
  1494.          if(oldUnscaledWidth > param1 || textField.text != label || labelChanged || styleChangedFlag)
  1495.          {
  1496.             textField.text = label;
  1497.             _loc6_ = textField.truncateToFit();
  1498.             if(!toolTipSet)
  1499.             {
  1500.                if(_loc6_)
  1501.                {
  1502.                   super.toolTip = label;
  1503.                }
  1504.                else
  1505.                {
  1506.                   super.toolTip = null;
  1507.                }
  1508.             }
  1509.             styleChangedFlag = false;
  1510.             labelChanged = false;
  1511.          }
  1512.          oldUnscaledWidth = param1;
  1513.       }
  1514.       
  1515.       private function stage_mouseLeaveHandler(param1:Event) : void
  1516.       {
  1517.          mx_internal::phase = ButtonPhase.UP;
  1518.          mx_internal::buttonReleased();
  1519.       }
  1520.       
  1521.       public function set listData(param1:BaseListData) : void
  1522.       {
  1523.          _listData = param1;
  1524.       }
  1525.    }
  1526. }
  1527.  
  1528.