home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / qs / controls / fisheyeClasses / FisheyeBase.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  17.3 KB  |  544 lines

  1. package qs.controls.fisheyeClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Sprite;
  5.    import flash.events.Event;
  6.    import flash.events.MouseEvent;
  7.    import mx.core.ClassFactory;
  8.    import mx.core.IDataRenderer;
  9.    import mx.core.IFactory;
  10.    import mx.core.UIComponent;
  11.    import qs.controls.CachedLabel;
  12.    import qs.controls.LayoutAnimator;
  13.    
  14.    public class FisheyeBase extends UIComponent
  15.    {
  16.       protected var renderers:Array = [];
  17.       
  18.       protected var renderersDirty:Boolean = true;
  19.       
  20.       protected var selectedItemIndex:Number = NaN;
  21.       
  22.       private var _items:Array = [];
  23.       
  24.       public var selectFirstItem:Boolean = false;
  25.       
  26.       private var _pendingItems:Array;
  27.       
  28.       protected var hilightedItemIndex:Number = NaN;
  29.       
  30.       protected var itemsChanged:Boolean = false;
  31.       
  32.       protected var animator:LayoutAnimator;
  33.       
  34.       private var _selectionEnabled:Boolean = true;
  35.       
  36.       private var _itemRendererFactory:IFactory;
  37.       
  38.       public function FisheyeBase()
  39.       {
  40.          super();
  41.          this._itemRendererFactory = new ClassFactory(CachedLabel);
  42.          addEventListener(MouseEvent.MOUSE_MOVE,this.updateHilight);
  43.          addEventListener(MouseEvent.ROLL_OUT,this.removeHilight);
  44.          addEventListener(MouseEvent.MOUSE_DOWN,this.updateSelection);
  45.          var _loc1_:Sprite = new Sprite();
  46.          addChild(_loc1_);
  47.          mask = _loc1_;
  48.          _loc1_.graphics.beginFill(0);
  49.          _loc1_.graphics.drawRect(0,0,10,10);
  50.          _loc1_.graphics.endFill();
  51.          this.animator = new LayoutAnimator();
  52.          this.animator.layoutFunction = this.generateLayout;
  53.       }
  54.       
  55.       protected function get defaultSpacingWithDefault() : Number
  56.       {
  57.          var _loc1_:Number = getStyle("defaultSpacing");
  58.          if(isNaN(_loc1_))
  59.          {
  60.             _loc1_ = 0;
  61.          }
  62.          return _loc1_;
  63.       }
  64.       
  65.       protected function align(param1:Array, param2:FisheyeAxis) : void
  66.       {
  67.          var _loc4_:int = 0;
  68.          var _loc5_:FisheyeItem = null;
  69.          var _loc6_:Number = NaN;
  70.          var _loc7_:int = 0;
  71.          var _loc8_:Number = NaN;
  72.          var _loc9_:int = 0;
  73.          var _loc10_:int = 0;
  74.          var _loc3_:String = getStyle(param2.align);
  75.          _loc4_ = int(param1.length);
  76.          if(_loc4_ == 0)
  77.          {
  78.             return;
  79.          }
  80.          switch(_loc3_)
  81.          {
  82.             case "right":
  83.             case "bottom":
  84.                _loc5_ = param1[_loc4_ - 1];
  85.                _loc6_ = this[param2.unscaled] - (_loc5_[param2.pos] + param1[_loc4_ - 1][param2.EOM] * _loc5_.scale);
  86.                _loc9_ = 0;
  87.                while(_loc9_ < _loc4_)
  88.                {
  89.                   param1[_loc9_][param2.pos] += _loc6_;
  90.                   _loc9_++;
  91.                }
  92.                break;
  93.             case "left":
  94.             case "top":
  95.                break;
  96.             case "center":
  97.             default:
  98.                _loc7_ = Math.floor(_loc4_ / 2);
  99.                _loc5_ = param1[_loc4_ - 1];
  100.                _loc8_ = _loc5_[param2.pos] + _loc5_[param2.EOM] * _loc5_.scale;
  101.                _loc6_ = this[param2.unscaled] / 2 - _loc8_ / 2;
  102.                _loc10_ = 0;
  103.                while(_loc10_ < _loc4_)
  104.                {
  105.                   param1[_loc10_][param2.pos] += _loc6_;
  106.                   _loc10_++;
  107.                }
  108.          }
  109.       }
  110.       
  111.       [Bindable("change")]
  112.       public function get highlightedItem() : Object
  113.       {
  114.          return isNaN(this.hilightedItemIndex) ? null : this._items[this.hilightedItemIndex];
  115.       }
  116.       
  117.       protected function populateMajorAxisForDefault(param1:Array, param2:FisheyeAxis, param3:Number) : FisheyeParameters
  118.       {
  119.          var _loc4_:Number = NaN;
  120.          var _loc9_:FisheyeItem = null;
  121.          var _loc12_:Number = NaN;
  122.          var _loc5_:int = int(param1.length);
  123.          var _loc6_:FisheyeParameters = new FisheyeParameters();
  124.          this.populateParameters(_loc6_,false);
  125.          var _loc7_:Number = _loc6_.spacing * (_loc5_ - 1);
  126.          var _loc8_:Number = 0;
  127.          var _loc10_:int = 0;
  128.          while(_loc10_ < _loc5_)
  129.          {
  130.             _loc8_ += param1[_loc10_][param2.EOM];
  131.             _loc10_++;
  132.          }
  133.          if(_loc8_ > 0)
  134.          {
  135.             _loc12_ = (param3 - _loc7_) / _loc8_;
  136.             _loc6_.minScale = Math.min(_loc6_.minScale,_loc12_);
  137.          }
  138.          _loc4_ = 0;
  139.          var _loc11_:int = 0;
  140.          while(_loc11_ < _loc5_)
  141.          {
  142.             _loc9_ = param1[_loc11_];
  143.             _loc9_.scale = _loc6_.minScale;
  144.             _loc9_[param2.pos] = _loc4_;
  145.             _loc4_ += _loc9_[param2.EOM] * _loc6_.minScale + _loc6_.spacing;
  146.             _loc11_++;
  147.          }
  148.          return _loc6_;
  149.       }
  150.       
  151.       protected function findItemForPosition(param1:Number, param2:Number) : Number
  152.       {
  153.          return NaN;
  154.       }
  155.       
  156.       private function removeHilight(param1:MouseEvent) : void
  157.       {
  158.          this.hilightedItemIndex = NaN;
  159.          this.updateState();
  160.          this.animator.invalidateLayout();
  161.       }
  162.       
  163.       public function get selectionEnabled() : Boolean
  164.       {
  165.          return this._selectionEnabled;
  166.       }
  167.       
  168.       public function set selectedItem(param1:Object) : void
  169.       {
  170.          var _loc2_:Number = NaN;
  171.          var _loc3_:int = 0;
  172.          while(_loc3_ < this._items.length)
  173.          {
  174.             if(param1 == this._items[_loc3_])
  175.             {
  176.                _loc2_ = _loc3_;
  177.                break;
  178.             }
  179.             _loc3_++;
  180.          }
  181.          this.selectedIndex = _loc2_;
  182.       }
  183.       
  184.       [Bindable("change")]
  185.       public function get hilightedIndex() : int
  186.       {
  187.          return isNaN(this.hilightedItemIndex) ? -1 : int(this.hilightedItemIndex);
  188.       }
  189.       
  190.       public function set selectionEnabled(param1:Boolean) : void
  191.       {
  192.          if(this._selectionEnabled == param1)
  193.          {
  194.             return;
  195.          }
  196.          this._selectionEnabled = param1;
  197.          this.selectedIndex = this.selectedIndex;
  198.       }
  199.       
  200.       private function updateHilight(param1:MouseEvent) : void
  201.       {
  202.          var _loc2_:Number = this.findItemForPosition(this.mouseX,this.mouseY);
  203.          if(_loc2_ == this.hilightedItemIndex)
  204.          {
  205.             return;
  206.          }
  207.          this.hilightedItemIndex = _loc2_;
  208.          this.updateState();
  209.          this.animator.invalidateLayout();
  210.       }
  211.       
  212.       public function layout() : void
  213.       {
  214.          this.animator.layout(true);
  215.       }
  216.       
  217.       public function get dataProvider() : Array
  218.       {
  219.          return this._items;
  220.       }
  221.       
  222.       public function set hilightedIndex(param1:int) : void
  223.       {
  224.          var _loc2_:Number = param1 < 0 || param1 >= this._items.length ? NaN : param1;
  225.          if(_loc2_ != this.hilightedItemIndex)
  226.          {
  227.             this.hilightedItemIndex = _loc2_;
  228.             this.updateState();
  229.             this.animator.invalidateLayout();
  230.          }
  231.       }
  232.       
  233.       protected function updateSelection(param1:MouseEvent) : void
  234.       {
  235.          if(this._selectionEnabled == false)
  236.          {
  237.             return;
  238.          }
  239.          var _loc2_:Number = this.findItemForPosition(this.mouseX,this.mouseY);
  240.          if(this.selectedItemIndex == _loc2_)
  241.          {
  242.             this.selectedIndex = -1;
  243.          }
  244.          else
  245.          {
  246.             this.selectedIndex = _loc2_;
  247.          }
  248.          this.updateState();
  249.          this.animator.invalidateLayout();
  250.       }
  251.       
  252.       public function invalidateLayout() : void
  253.       {
  254.          this.animator.invalidateLayout(false);
  255.       }
  256.       
  257.       override protected function commitProperties() : void
  258.       {
  259.          var _loc1_:DisplayObject = null;
  260.          var _loc2_:int = 0;
  261.          var _loc3_:int = 0;
  262.          var _loc4_:UIComponent = null;
  263.          if(this._pendingItems != null)
  264.          {
  265.             this._items = this._pendingItems;
  266.             this._pendingItems = null;
  267.          }
  268.          this.itemsChanged = false;
  269.          if(this.renderersDirty)
  270.          {
  271.             this.renderersDirty = false;
  272.             _loc1_ = mask;
  273.             _loc2_ = numChildren - 1;
  274.             while(_loc2_ >= 0)
  275.             {
  276.                removeChildAt(_loc2_);
  277.                _loc2_--;
  278.             }
  279.             addChild(_loc1_);
  280.             this.renderers = [];
  281.             _loc3_ = 0;
  282.             while(_loc3_ < this._items.length)
  283.             {
  284.                _loc4_ = this._itemRendererFactory.newInstance();
  285.                IDataRenderer(_loc4_).data = this._items[_loc3_];
  286.                this.renderers[_loc3_] = _loc4_;
  287.                addChild(_loc4_);
  288.                _loc3_++;
  289.             }
  290.             this.animator.items = this.renderers;
  291.          }
  292.          invalidateSize();
  293.       }
  294.       
  295.       override public function styleChanged(param1:String) : void
  296.       {
  297.          if(param1 == "animationSpeed")
  298.          {
  299.             this.animator.animationSpeed = getStyle("animationSpeed");
  300.          }
  301.          invalidateSize();
  302.          invalidateDisplayList();
  303.          this.animator.invalidateLayout();
  304.       }
  305.       
  306.       [Bindable("change")]
  307.       public function get selectedItem() : Object
  308.       {
  309.          return isNaN(this.selectedItemIndex) ? null : this._items[this.selectedItemIndex];
  310.       }
  311.       
  312.       protected function updateState() : void
  313.       {
  314.          var _loc2_:String = null;
  315.          var _loc3_:String = null;
  316.          var _loc4_:String = null;
  317.          var _loc5_:String = null;
  318.          var _loc6_:Boolean = false;
  319.          var _loc7_:int = 0;
  320.          var _loc8_:int = 0;
  321.          var _loc9_:int = 0;
  322.          var _loc10_:int = 0;
  323.          var _loc1_:String = getStyle("stateProperty");
  324.          if(_loc1_ != null)
  325.          {
  326.             _loc2_ = getStyle("rolloverValue");
  327.             _loc3_ = getStyle("selectedValue");
  328.             _loc4_ = getStyle("defaultValue");
  329.             _loc5_ = getStyle("unselectedValue");
  330.             if(_loc5_ == null || isNaN(this.selectedItemIndex) && isNaN(this.hilightedItemIndex))
  331.             {
  332.                _loc5_ = getStyle("defaultValue");
  333.             }
  334.             _loc6_ = false;
  335.             _loc7_ = 0;
  336.             while(_loc7_ < this.renderers.length)
  337.             {
  338.                _loc8_ = this.selectedItemIndex;
  339.                _loc9_ = _loc7_ - this.selectedItemIndex;
  340.                _loc10_ = Math.abs(_loc7_ - this.selectedItemIndex);
  341.                this.renderers[_loc7_][_loc1_] = _loc7_ == this.selectedItemIndex ? _loc3_ : (_loc7_ == this.hilightedItemIndex ? _loc2_ : _loc5_);
  342.                if(_loc7_ == this.selectedItemIndex || _loc7_ == this.hilightedItemIndex)
  343.                {
  344.                   _loc6_ = true;
  345.                }
  346.                _loc7_++;
  347.             }
  348.             if(!_loc6_ && this.selectFirstItem)
  349.             {
  350.                this.hilightedItemIndex = 0;
  351.                this.selectedItemIndex = -1;
  352.                if(this.renderers[0] != null)
  353.                {
  354.                   this.renderers[0][_loc1_] = _loc2_;
  355.                }
  356.             }
  357.          }
  358.       }
  359.       
  360.       private function calcDistanceFactor(param1:FisheyeParameters, param2:Number) : Number
  361.       {
  362.          var _loc3_:Number = 1 / param1.scaleRadius;
  363.          return Math.max(0,1 - Math.pow(param2 * _loc3_,param1.scaleSlope));
  364.       }
  365.       
  366.       public function get maxIndex() : int
  367.       {
  368.          return isNaN(this._items.length) ? -1 : int(this._items.length);
  369.       }
  370.       
  371.       private function adjustParameters(param1:Array, param2:Number, param3:FisheyeParameters, param4:Number, param5:FisheyeAxis) : void
  372.       {
  373.          var _loc12_:FisheyeItem = null;
  374.          var _loc13_:Number = NaN;
  375.          var _loc14_:Number = NaN;
  376.          var _loc15_:Number = NaN;
  377.          var _loc16_:Number = NaN;
  378.          var _loc17_:Number = NaN;
  379.          var _loc6_:int = int(param1.length);
  380.          var _loc7_:Number = param3.spacing * (_loc6_ - 1);
  381.          var _loc8_:Number = 0;
  382.          var _loc9_:Number = 0;
  383.          var _loc10_:int = 0;
  384.          while(_loc10_ < _loc6_)
  385.          {
  386.             _loc12_ = param1[_loc10_];
  387.             _loc13_ = Math.abs(param2 - _loc10_);
  388.             _loc14_ = this.calcDistanceFactor(param3,_loc13_);
  389.             _loc15_ = param3.maxScale * _loc14_;
  390.             _loc16_ = 1 - _loc14_;
  391.             _loc17_ = Number(_loc12_[param5.EOM]);
  392.             _loc8_ += _loc17_ * _loc15_;
  393.             _loc9_ += _loc17_ * _loc16_;
  394.             _loc10_++;
  395.          }
  396.          var _loc11_:Number = _loc9_ > 0 ? (param4 - _loc7_ - _loc8_) / _loc9_ : 0;
  397.          _loc11_ = Math.min(param3.minScale,_loc11_);
  398.          param3.minScale = _loc11_;
  399.       }
  400.       
  401.       public function set itemRenderer(param1:IFactory) : void
  402.       {
  403.          this._itemRendererFactory = param1;
  404.          this.renderersDirty = true;
  405.          invalidateProperties();
  406.       }
  407.       
  408.       public function set selectedIndex(param1:int) : void
  409.       {
  410.          var _loc2_:Number = param1 < 0 || param1 >= this._items.length ? NaN : param1;
  411.          if(_loc2_ != this.selectedItemIndex)
  412.          {
  413.             this.selectedItemIndex = _loc2_;
  414.             this.updateState();
  415.             this.animator.invalidateLayout();
  416.             dispatchEvent(new Event("change"));
  417.          }
  418.          if(!isNaN(_loc2_))
  419.          {
  420.             dispatchEvent(new Event("select"));
  421.          }
  422.       }
  423.       
  424.       private function populateParameters(param1:FisheyeParameters, param2:Boolean) : void
  425.       {
  426.          if(param2 == false)
  427.          {
  428.             param1.minScale = getStyle("defaultScale");
  429.             if(isNaN(param1.minScale))
  430.             {
  431.                param1.minScale = 0.5;
  432.             }
  433.             param1.spacing = this.defaultSpacingWithDefault;
  434.          }
  435.          else
  436.          {
  437.             param1.minScale = getStyle("hilightMinScale");
  438.             if(isNaN(param1.minScale))
  439.             {
  440.                param1.minScale = getStyle("defaultScale");
  441.                if(isNaN(param1.minScale))
  442.                {
  443.                   param1.minScale = 0.5;
  444.                }
  445.             }
  446.             param1.spacing = getStyle("hilightSpacing");
  447.             if(isNaN(param1.spacing))
  448.             {
  449.                param1.spacing = this.defaultSpacingWithDefault;
  450.             }
  451.          }
  452.          param1.maxScale = getStyle("hilightMaxScale");
  453.          if(isNaN(param1.maxScale))
  454.          {
  455.             param1.maxScale = 1;
  456.          }
  457.          param1.scaleRadius = getStyle("hilightScaleRadius");
  458.          if(isNaN(param1.scaleRadius))
  459.          {
  460.             param1.scaleRadius = 2;
  461.          }
  462.          param1.scaleRadius = Math.max(1,param1.scaleRadius);
  463.          param1.scaleSlope = getStyle("hilightScaleSlope");
  464.          if(isNaN(param1.scaleSlope))
  465.          {
  466.             param1.scaleSlope = 0.75;
  467.          }
  468.       }
  469.       
  470.       protected function get maxScaleWithDefault() : Number
  471.       {
  472.          var _loc1_:Number = getStyle("hilightMaxScale");
  473.          if(isNaN(_loc1_))
  474.          {
  475.             _loc1_ = 1;
  476.          }
  477.          return _loc1_;
  478.       }
  479.       
  480.       public function set dataProvider(param1:Array) : void
  481.       {
  482.          this._pendingItems = param1;
  483.          this.renderersDirty = true;
  484.          this.itemsChanged = true;
  485.          invalidateProperties();
  486.          dispatchEvent(new Event("loaded"));
  487.       }
  488.       
  489.       [Bindable("change")]
  490.       public function get selectedIndex() : int
  491.       {
  492.          return isNaN(this.selectedItemIndex) ? -1 : int(this.selectedItemIndex);
  493.       }
  494.       
  495.       protected function populateMajorAxisFor(param1:Array, param2:Number, param3:Number, param4:FisheyeAxis) : FisheyeParameters
  496.       {
  497.          var _loc5_:Number = NaN;
  498.          var _loc7_:FisheyeItem = null;
  499.          var _loc10_:Number = NaN;
  500.          var _loc11_:Number = NaN;
  501.          var _loc12_:Number = NaN;
  502.          var _loc6_:int = int(param1.length);
  503.          var _loc8_:FisheyeParameters = new FisheyeParameters();
  504.          this.populateParameters(_loc8_,true);
  505.          this.adjustParameters(param1,param2,_loc8_,param3,param4);
  506.          _loc5_ = 0;
  507.          var _loc9_:int = 0;
  508.          while(_loc9_ < _loc6_)
  509.          {
  510.             _loc7_ = param1[_loc9_];
  511.             _loc10_ = Math.abs(param2 - _loc9_);
  512.             _loc11_ = this.calcDistanceFactor(_loc8_,_loc10_);
  513.             _loc12_ = Math.max(0,_loc8_.minScale + (_loc8_.maxScale - _loc8_.minScale) * _loc11_);
  514.             _loc7_[param4.pos] = _loc5_;
  515.             _loc7_.scale = _loc12_;
  516.             _loc5_ += _loc7_[param4.EOM] * _loc12_ + _loc8_.spacing;
  517.             _loc9_++;
  518.          }
  519.          return _loc8_;
  520.       }
  521.       
  522.       public function get itemRenderer() : IFactory
  523.       {
  524.          return this._itemRendererFactory;
  525.       }
  526.       
  527.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  528.       {
  529.          graphics.clear();
  530.          graphics.moveTo(0,0);
  531.          graphics.beginFill(0,0);
  532.          graphics.drawRect(0,0,param1,param2);
  533.          mask.width = param1;
  534.          mask.height = param2;
  535.          this.animator.invalidateLayout();
  536.       }
  537.       
  538.       protected function generateLayout() : void
  539.       {
  540.       }
  541.    }
  542. }
  543.  
  544.