home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / RadioButton.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  11.4 KB  |  396 lines
  1. package mx.controls
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.KeyboardEvent;
  5.    import flash.events.MouseEvent;
  6.    import flash.ui.Keyboard;
  7.    import mx.core.FlexVersion;
  8.    import mx.core.IFlexDisplayObject;
  9.    import mx.core.IToggleButton;
  10.    import mx.core.mx_internal;
  11.    import mx.events.FlexEvent;
  12.    import mx.events.ItemClickEvent;
  13.    import mx.managers.IFocusManager;
  14.    import mx.managers.IFocusManagerGroup;
  15.    
  16.    use namespace mx_internal;
  17.    
  18.    public class RadioButton extends Button implements IFocusManagerGroup, IToggleButton
  19.    {
  20.       mx_internal static var createAccessibilityImplementation:Function;
  21.       
  22.       mx_internal static const VERSION:String = "3.5.0.12683";
  23.       
  24.       private var _group:RadioButtonGroup;
  25.       
  26.       mx_internal var _groupName:String;
  27.       
  28.       private var _value:Object;
  29.       
  30.       private var groupChanged:Boolean = false;
  31.       
  32.       mx_internal var indexNumber:int = 0;
  33.       
  34.       public function RadioButton()
  35.       {
  36.          super();
  37.          mx_internal::_labelPlacement = "";
  38.          mx_internal::_toggle = true;
  39.          groupName = "radioGroup";
  40.          addEventListener(FlexEvent.ADD,addHandler);
  41.          mx_internal::centerContent = false;
  42.          mx_internal::extraSpacing = 8;
  43.       }
  44.       
  45.       private function addHandler(param1:FlexEvent) : void
  46.       {
  47.          if(!_group && initialized)
  48.          {
  49.             addToGroup();
  50.          }
  51.       }
  52.       
  53.       private function setNext(param1:Boolean = true) : void
  54.       {
  55.          var _loc5_:RadioButton = null;
  56.          var _loc2_:RadioButtonGroup = group;
  57.          var _loc3_:IFocusManager = focusManager;
  58.          if(_loc3_)
  59.          {
  60.             _loc3_.showFocusIndicator = true;
  61.          }
  62.          var _loc4_:int = mx_internal::indexNumber + 1;
  63.          while(_loc4_ < _loc2_.numRadioButtons)
  64.          {
  65.             _loc5_ = _loc2_.getRadioButtonAt(_loc4_);
  66.             if((Boolean(_loc5_)) && _loc5_.enabled)
  67.             {
  68.                if(param1)
  69.                {
  70.                   _loc2_.mx_internal::setSelection(_loc5_);
  71.                }
  72.                _loc5_.setFocus();
  73.                return;
  74.             }
  75.             _loc4_++;
  76.          }
  77.          if(param1 && _loc2_.getRadioButtonAt(mx_internal::indexNumber) != _loc2_.selection)
  78.          {
  79.             _loc2_.mx_internal::setSelection(this);
  80.          }
  81.          this.drawFocus(true);
  82.       }
  83.       
  84.       private function addToGroup() : Object
  85.       {
  86.          var _loc1_:RadioButtonGroup = group;
  87.          if(_loc1_)
  88.          {
  89.             _loc1_.mx_internal::addInstance(this);
  90.          }
  91.          return _loc1_;
  92.       }
  93.       
  94.       override protected function commitProperties() : void
  95.       {
  96.          super.commitProperties();
  97.          if(groupChanged)
  98.          {
  99.             addToGroup();
  100.             groupChanged = false;
  101.          }
  102.       }
  103.       
  104.       override protected function clickHandler(param1:MouseEvent) : void
  105.       {
  106.          if(!enabled || selected)
  107.          {
  108.             return;
  109.          }
  110.          if(!_group)
  111.          {
  112.             addToGroup();
  113.          }
  114.          super.clickHandler(param1);
  115.          group.mx_internal::setSelection(this);
  116.          var _loc2_:ItemClickEvent = new ItemClickEvent(ItemClickEvent.ITEM_CLICK);
  117.          _loc2_.label = label;
  118.          _loc2_.index = mx_internal::indexNumber;
  119.          _loc2_.relatedObject = this;
  120.          _loc2_.item = value;
  121.          group.dispatchEvent(_loc2_);
  122.       }
  123.       
  124.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  125.       {
  126.          super.keyUpHandler(param1);
  127.          if(param1.keyCode == Keyboard.SPACE && !mx_internal::_toggle)
  128.          {
  129.             mx_internal::_toggle = true;
  130.          }
  131.       }
  132.       
  133.       [Bindable("labelPlacementChanged")]
  134.       override public function get labelPlacement() : String
  135.       {
  136.          var _loc1_:String = ButtonLabelPlacement.RIGHT;
  137.          if(mx_internal::_labelPlacement != "")
  138.          {
  139.             _loc1_ = mx_internal::_labelPlacement;
  140.          }
  141.          else if(Boolean(_group) && _group.labelPlacement != "")
  142.          {
  143.             _loc1_ = _group.labelPlacement;
  144.          }
  145.          return _loc1_;
  146.       }
  147.       
  148.       public function set groupName(param1:String) : void
  149.       {
  150.          if(!param1 || param1 == "")
  151.          {
  152.             return;
  153.          }
  154.          mx_internal::deleteGroup();
  155.          mx_internal::_groupName = param1;
  156.          groupChanged = true;
  157.          invalidateProperties();
  158.          invalidateDisplayList();
  159.          dispatchEvent(new Event("groupNameChanged"));
  160.       }
  161.       
  162.       override protected function initializeAccessibility() : void
  163.       {
  164.          if(RadioButton.mx_internal::createAccessibilityImplementation != null)
  165.          {
  166.             RadioButton.mx_internal::createAccessibilityImplementation(this);
  167.          }
  168.       }
  169.       
  170.       private function setThis() : void
  171.       {
  172.          if(!_group)
  173.          {
  174.             addToGroup();
  175.          }
  176.          var _loc1_:RadioButtonGroup = group;
  177.          if(_loc1_.selection != this)
  178.          {
  179.             _loc1_.mx_internal::setSelection(this);
  180.          }
  181.       }
  182.       
  183.       override public function get emphasized() : Boolean
  184.       {
  185.          return false;
  186.       }
  187.       
  188.       override public function get toggle() : Boolean
  189.       {
  190.          return super.toggle;
  191.       }
  192.       
  193.       override protected function measure() : void
  194.       {
  195.          var _loc1_:Number = NaN;
  196.          var _loc2_:Number = NaN;
  197.          var _loc3_:Number = NaN;
  198.          var _loc4_:Number = NaN;
  199.          super.measure();
  200.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  201.          {
  202.             _loc1_ = measureText(label).height;
  203.             _loc2_ = !!mx_internal::currentIcon ? Number(mx_internal::currentIcon.height) : 0;
  204.             if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  205.             {
  206.                _loc3_ = Math.max(_loc1_,_loc2_);
  207.             }
  208.             else
  209.             {
  210.                _loc3_ = _loc1_ + _loc2_;
  211.                _loc4_ = getStyle("verticalGap");
  212.                if(_loc2_ != 0 && !isNaN(_loc4_))
  213.                {
  214.                   _loc3_ += _loc4_;
  215.                }
  216.             }
  217.             measuredMinHeight = measuredHeight = Math.max(_loc3_,18);
  218.          }
  219.       }
  220.       
  221.       override public function set toggle(param1:Boolean) : void
  222.       {
  223.       }
  224.       
  225.       mx_internal function deleteGroup() : void
  226.       {
  227.          try
  228.          {
  229.             if(document[groupName])
  230.             {
  231.                delete document[groupName];
  232.             }
  233.          }
  234.          catch(e:Error)
  235.          {
  236.             try
  237.             {
  238.                if(document.automaticRadioButtonGroups[groupName])
  239.                {
  240.                   delete document.automaticRadioButtonGroups[groupName];
  241.                }
  242.             }
  243.             catch(e1:Error)
  244.             {
  245.             }
  246.          }
  247.       }
  248.       
  249.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  250.       {
  251.          if(!enabled)
  252.          {
  253.             return;
  254.          }
  255.          switch(param1.keyCode)
  256.          {
  257.             case Keyboard.DOWN:
  258.                setNext(!param1.ctrlKey);
  259.                param1.stopPropagation();
  260.                break;
  261.             case Keyboard.UP:
  262.                setPrev(!param1.ctrlKey);
  263.                param1.stopPropagation();
  264.                break;
  265.             case Keyboard.LEFT:
  266.                setPrev(!param1.ctrlKey);
  267.                param1.stopPropagation();
  268.                break;
  269.             case Keyboard.RIGHT:
  270.                setNext(!param1.ctrlKey);
  271.                param1.stopPropagation();
  272.                break;
  273.             case Keyboard.SPACE:
  274.                setThis();
  275.                mx_internal::_toggle = false;
  276.             default:
  277.                super.keyDownHandler(param1);
  278.          }
  279.       }
  280.       
  281.       [Bindable("groupNameChanged")]
  282.       public function get groupName() : String
  283.       {
  284.          return mx_internal::_groupName;
  285.       }
  286.       
  287.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  288.       {
  289.          super.updateDisplayList(param1,param2);
  290.          if(groupChanged)
  291.          {
  292.             addToGroup();
  293.             groupChanged = false;
  294.          }
  295.          if(_group && mx_internal::_selected && _group.selection != this)
  296.          {
  297.             group.mx_internal::setSelection(this,false);
  298.          }
  299.       }
  300.       
  301.       [Bindable("valueChanged")]
  302.       public function get value() : Object
  303.       {
  304.          return _value;
  305.       }
  306.       
  307.       public function set value(param1:Object) : void
  308.       {
  309.          _value = param1;
  310.          dispatchEvent(new Event("valueChanged"));
  311.          if(selected && Boolean(group))
  312.          {
  313.             group.dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  314.          }
  315.       }
  316.       
  317.       private function setPrev(param1:Boolean = true) : void
  318.       {
  319.          var _loc5_:RadioButton = null;
  320.          var _loc2_:RadioButtonGroup = group;
  321.          var _loc3_:IFocusManager = focusManager;
  322.          if(_loc3_)
  323.          {
  324.             _loc3_.showFocusIndicator = true;
  325.          }
  326.          var _loc4_:int = 1;
  327.          while(_loc4_ <= mx_internal::indexNumber)
  328.          {
  329.             _loc5_ = _loc2_.getRadioButtonAt(mx_internal::indexNumber - _loc4_);
  330.             if((Boolean(_loc5_)) && _loc5_.enabled)
  331.             {
  332.                if(param1)
  333.                {
  334.                   _loc2_.mx_internal::setSelection(_loc5_);
  335.                }
  336.                _loc5_.setFocus();
  337.                return;
  338.             }
  339.             _loc4_++;
  340.          }
  341.          if(param1 && _loc2_.getRadioButtonAt(mx_internal::indexNumber) != _loc2_.selection)
  342.          {
  343.             _loc2_.mx_internal::setSelection(this);
  344.          }
  345.          this.drawFocus(true);
  346.       }
  347.       
  348.       public function set group(param1:RadioButtonGroup) : void
  349.       {
  350.          _group = param1;
  351.       }
  352.       
  353.       public function get group() : RadioButtonGroup
  354.       {
  355.          var g:RadioButtonGroup = null;
  356.          if(!document)
  357.          {
  358.             return _group;
  359.          }
  360.          if(!_group)
  361.          {
  362.             if(Boolean(groupName) && groupName != "")
  363.             {
  364.                try
  365.                {
  366.                   g = RadioButtonGroup(document[groupName]);
  367.                }
  368.                catch(e:Error)
  369.                {
  370.                   if(Boolean(document.automaticRadioButtonGroups) && Boolean(document.automaticRadioButtonGroups[groupName]))
  371.                   {
  372.                      g = RadioButtonGroup(document.automaticRadioButtonGroups[groupName]);
  373.                   }
  374.                }
  375.                if(!g)
  376.                {
  377.                   g = new RadioButtonGroup(IFlexDisplayObject(document));
  378.                   if(!document.automaticRadioButtonGroups)
  379.                   {
  380.                      document.automaticRadioButtonGroups = {};
  381.                   }
  382.                   document.automaticRadioButtonGroups[groupName] = g;
  383.                }
  384.                else if(!(g is RadioButtonGroup))
  385.                {
  386.                   return null;
  387.                }
  388.                _group = g;
  389.             }
  390.          }
  391.          return _group;
  392.       }
  393.    }
  394. }
  395.  
  396.