home *** CD-ROM | disk | FTP | other *** search
/ Hentai Interactivo 52 / HENTAI52.bin / flip2.swf / scripts / __Packages / mx / controls / scrollClasses / ScrollBar.as next >
Text File  |  2008-09-03  |  13KB  |  392 lines
  1. class mx.controls.scrollClasses.ScrollBar extends mx.core.UIComponent
  2. {
  3.    static var symbolOwner = mx.core.UIComponent;
  4.    var className = "ScrollBar";
  5.    var minPos = 0;
  6.    var maxPos = 0;
  7.    var pageSize = 0;
  8.    var largeScroll = 0;
  9.    var smallScroll = 1;
  10.    var _scrollPosition = 0;
  11.    var scrollTrackName = "ScrollTrack";
  12.    var scrollTrackOverName = "";
  13.    var scrollTrackDownName = "";
  14.    var upArrowName = "BtnUpArrow";
  15.    var upArrowUpName = "ScrollUpArrowUp";
  16.    var upArrowOverName = "ScrollUpArrowOver";
  17.    var upArrowDownName = "ScrollUpArrowDown";
  18.    var downArrowName = "BtnDownArrow";
  19.    var downArrowUpName = "ScrollDownArrowUp";
  20.    var downArrowOverName = "ScrollDownArrowOver";
  21.    var downArrowDownName = "ScrollDownArrowDown";
  22.    var thumbTopName = "ScrollThumbTopUp";
  23.    var thumbMiddleName = "ScrollThumbMiddleUp";
  24.    var thumbBottomName = "ScrollThumbBottomUp";
  25.    var thumbGripName = "ScrollThumbGripUp";
  26.    static var skinIDTrack = 0;
  27.    static var skinIDTrackOver = 1;
  28.    static var skinIDTrackDown = 2;
  29.    static var skinIDUpArrow = 3;
  30.    static var skinIDDownArrow = 4;
  31.    static var skinIDThumb = 5;
  32.    var idNames = new Array("scrollTrack_mc","scrollTrackOver_mc","scrollTrackDown_mc","upArrow_mc","downArrow_mc");
  33.    var clipParameters = {minPos:1,maxPos:1,pageSize:1,scrollPosition:1,lineScrollSize:1,pageScrollSize:1,visible:1,enabled:1};
  34.    static var mergedClipParameters = mx.core.UIObject.mergeClipParameters(mx.controls.scrollClasses.ScrollBar.prototype.clipParameters,mx.core.UIComponent.prototype.clipParameters);
  35.    var initializing = true;
  36.    function ScrollBar()
  37.    {
  38.       super();
  39.    }
  40.    function get scrollPosition()
  41.    {
  42.       return this._scrollPosition;
  43.    }
  44.    function set scrollPosition(pos)
  45.    {
  46.       this._scrollPosition = pos;
  47.       if(this.isScrolling != true)
  48.       {
  49.          pos = Math.min(pos,this.maxPos);
  50.          pos = Math.max(pos,this.minPos);
  51.          var _loc3_ = (pos - this.minPos) * (this.scrollTrack_mc.height - this.scrollThumb_mc._height) / (this.maxPos - this.minPos) + this.scrollTrack_mc.top;
  52.          this.scrollThumb_mc.move(0,_loc3_);
  53.       }
  54.    }
  55.    function get pageScrollSize()
  56.    {
  57.       return this.largeScroll;
  58.    }
  59.    function set pageScrollSize(lScroll)
  60.    {
  61.       this.largeScroll = lScroll;
  62.    }
  63.    function set lineScrollSize(sScroll)
  64.    {
  65.       this.smallScroll = sScroll;
  66.    }
  67.    function get lineScrollSize()
  68.    {
  69.       return this.smallScroll;
  70.    }
  71.    function get virtualHeight()
  72.    {
  73.       return this.__height;
  74.    }
  75.    function init(Void)
  76.    {
  77.       super.init();
  78.       this._scrollPosition = 0;
  79.       this.tabEnabled = false;
  80.       this.focusEnabled = false;
  81.       this.boundingBox_mc._visible = false;
  82.       this.boundingBox_mc._width = this.boundingBox_mc._height = 0;
  83.    }
  84.    function createChildren(Void)
  85.    {
  86.       if(this.scrollTrack_mc == undefined)
  87.       {
  88.          this.setSkin(mx.controls.scrollClasses.ScrollBar.skinIDTrack,this.scrollTrackName);
  89.       }
  90.       this.scrollTrack_mc.visible = false;
  91.       var _loc3_ = new Object();
  92.       _loc3_.enabled = false;
  93.       _loc3_.preset = mx.controls.SimpleButton.falseDisabled;
  94.       _loc3_.initProperties = 0;
  95.       _loc3_.autoRepeat = true;
  96.       _loc3_.tabEnabled = false;
  97.       var _loc2_ = undefined;
  98.       if(this.upArrow_mc == undefined)
  99.       {
  100.          _loc2_ = this.createButton(this.upArrowName,"upArrow_mc",mx.controls.scrollClasses.ScrollBar.skinIDUpArrow,_loc3_);
  101.       }
  102.       _loc2_.buttonDownHandler = this.onUpArrow;
  103.       _loc2_.clickHandler = this.onScrollChanged;
  104.       this._minHeight = _loc2_.height;
  105.       this._minWidth = _loc2_.width;
  106.       if(this.downArrow_mc == undefined)
  107.       {
  108.          _loc2_ = this.createButton(this.downArrowName,"downArrow_mc",mx.controls.scrollClasses.ScrollBar.skinIDDownArrow,_loc3_);
  109.       }
  110.       _loc2_.buttonDownHandler = this.onDownArrow;
  111.       _loc2_.clickHandler = this.onScrollChanged;
  112.       this._minHeight += _loc2_.height;
  113.    }
  114.    function createButton(linkageName, id, skinID, o)
  115.    {
  116.       if(skinID == mx.controls.scrollClasses.ScrollBar.skinIDUpArrow)
  117.       {
  118.          o.falseUpSkin = this.upArrowUpName;
  119.          o.falseDownSkin = this.upArrowDownName;
  120.          o.falseOverSkin = this.upArrowOverName;
  121.       }
  122.       else
  123.       {
  124.          o.falseUpSkin = this.downArrowUpName;
  125.          o.falseDownSkin = this.downArrowDownName;
  126.          o.falseOverSkin = this.downArrowOverName;
  127.       }
  128.       var _loc3_ = this.createObject(linkageName,id,skinID,o);
  129.       this[id].visible = false;
  130.       this[id].useHandCursor = false;
  131.       return _loc3_;
  132.    }
  133.    function createThumb(Void)
  134.    {
  135.       var _loc2_ = new Object();
  136.       _loc2_.validateNow = true;
  137.       _loc2_.tabEnabled = false;
  138.       _loc2_.leftSkin = this.thumbTopName;
  139.       _loc2_.middleSkin = this.thumbMiddleName;
  140.       _loc2_.rightSkin = this.thumbBottomName;
  141.       _loc2_.gripSkin = this.thumbGripName;
  142.       this.createClassObject(mx.controls.scrollClasses.ScrollThumb,"scrollThumb_mc",mx.controls.scrollClasses.ScrollBar.skinIDThumb,_loc2_);
  143.    }
  144.    function setScrollProperties(pSize, mnPos, mxPos, ls)
  145.    {
  146.       var _loc4_ = undefined;
  147.       var _loc2_ = this.scrollTrack_mc;
  148.       this.pageSize = pSize;
  149.       this.largeScroll = !(ls != undefined && ls > 0) ? pSize : ls;
  150.       this.minPos = Math.max(mnPos,0);
  151.       this.maxPos = Math.max(mxPos,0);
  152.       this._scrollPosition = Math.max(this.minPos,this._scrollPosition);
  153.       this._scrollPosition = Math.min(this.maxPos,this._scrollPosition);
  154.       if(this.maxPos - this.minPos > 0 && this.enabled)
  155.       {
  156.          var _loc5_ = this._scrollPosition;
  157.          if(!this.initializing)
  158.          {
  159.             this.upArrow_mc.enabled = true;
  160.             this.downArrow_mc.enabled = true;
  161.          }
  162.          _loc2_.onPress = _loc2_.onDragOver = this.startTrackScroller;
  163.          _loc2_.onRelease = this.releaseScrolling;
  164.          _loc2_.onDragOut = _loc2_.stopScrolling = this.stopScrolling;
  165.          _loc2_.onReleaseOutside = this.releaseScrolling;
  166.          _loc2_.useHandCursor = false;
  167.          if(this.scrollThumb_mc == undefined)
  168.          {
  169.             this.createThumb();
  170.          }
  171.          var _loc3_ = this.scrollThumb_mc;
  172.          if(this.scrollTrackOverName.length > 0)
  173.          {
  174.             _loc2_.onRollOver = this.trackOver;
  175.             _loc2_.onRollOut = this.trackOut;
  176.          }
  177.          _loc4_ = this.pageSize / (this.maxPos - this.minPos + this.pageSize) * _loc2_.height;
  178.          if(_loc4_ < _loc3_.minHeight)
  179.          {
  180.             if(_loc2_.height < _loc3_.minHeight)
  181.             {
  182.                _loc3_.__set__visible(false);
  183.             }
  184.             else
  185.             {
  186.                _loc4_ = _loc3_.minHeight;
  187.                _loc3_.__set__visible(true);
  188.                _loc3_.setSize(this._minWidth,_loc3_.minHeight + 0);
  189.             }
  190.          }
  191.          else
  192.          {
  193.             _loc3_.__set__visible(true);
  194.             _loc3_.setSize(this._minWidth,_loc4_);
  195.          }
  196.          _loc3_.setRange(this.upArrow_mc.__get__height() + 0,this.__get__virtualHeight() - this.downArrow_mc.__get__height() - _loc3_.__get__height(),this.minPos,this.maxPos);
  197.          _loc5_ = Math.min(_loc5_,this.maxPos);
  198.          this.__set__scrollPosition(Math.max(_loc5_,this.minPos));
  199.       }
  200.       else
  201.       {
  202.          this.scrollThumb_mc.__set__visible(false);
  203.          if(!this.initializing)
  204.          {
  205.             this.upArrow_mc.enabled = false;
  206.             this.downArrow_mc.enabled = false;
  207.          }
  208.          delete _loc2_.onPress;
  209.          delete _loc2_.onDragOver;
  210.          delete _loc2_.onRelease;
  211.          delete _loc2_.onDragOut;
  212.          delete _loc2_.onRollOver;
  213.          delete _loc2_.onRollOut;
  214.          delete _loc2_.onReleaseOutside;
  215.       }
  216.       if(this.initializing)
  217.       {
  218.          this.scrollThumb_mc.__set__visible(false);
  219.       }
  220.    }
  221.    function setEnabled(enabledFlag)
  222.    {
  223.       super.setEnabled(enabledFlag);
  224.       this.setScrollProperties(this.pageSize,this.minPos,this.maxPos,this.largeScroll);
  225.    }
  226.    function draw(Void)
  227.    {
  228.       if(this.initializing)
  229.       {
  230.          this.initializing = false;
  231.          this.scrollTrack_mc.visible = true;
  232.          this.upArrow_mc.__set__visible(true);
  233.          this.downArrow_mc.__set__visible(true);
  234.       }
  235.       this.size();
  236.    }
  237.    function size(Void)
  238.    {
  239.       if(this._height == 1)
  240.       {
  241.          return undefined;
  242.       }
  243.       if(this.upArrow_mc == undefined)
  244.       {
  245.          return undefined;
  246.       }
  247.       var _loc3_ = this.upArrow_mc.__get__height();
  248.       var _loc2_ = this.downArrow_mc.__get__height();
  249.       this.upArrow_mc.move(0,0);
  250.       var _loc4_ = this.scrollTrack_mc;
  251.       _loc4_._y = _loc3_;
  252.       _loc4_._height = this.__get__virtualHeight() - _loc3_ - _loc2_;
  253.       this.downArrow_mc.move(0,this.__get__virtualHeight() - _loc2_);
  254.       this.setScrollProperties(this.pageSize,this.minPos,this.maxPos,this.largeScroll);
  255.    }
  256.    function dispatchScrollEvent(detail)
  257.    {
  258.       this.dispatchEvent({type:"scroll",detail:detail});
  259.    }
  260.    function isScrollBarKey(k)
  261.    {
  262.       if(k == 36)
  263.       {
  264.          if(this.__get__scrollPosition() != 0)
  265.          {
  266.             this.__set__scrollPosition(0);
  267.             this.dispatchScrollEvent(this.minMode);
  268.          }
  269.          return true;
  270.       }
  271.       if(k == 35)
  272.       {
  273.          if(this.__get__scrollPosition() < this.maxPos)
  274.          {
  275.             this.__set__scrollPosition(this.maxPos);
  276.             this.dispatchScrollEvent(this.maxMode);
  277.          }
  278.          return true;
  279.       }
  280.       return false;
  281.    }
  282.    function scrollIt(inc, mode)
  283.    {
  284.       var _loc3_ = this.smallScroll;
  285.       if(inc != "Line")
  286.       {
  287.          _loc3_ = this.largeScroll != 0 ? this.largeScroll : this.pageSize;
  288.       }
  289.       var _loc2_ = this._scrollPosition + mode * _loc3_;
  290.       if(_loc2_ > this.maxPos)
  291.       {
  292.          _loc2_ = this.maxPos;
  293.       }
  294.       else if(_loc2_ < this.minPos)
  295.       {
  296.          _loc2_ = this.minPos;
  297.       }
  298.       if(this.__get__scrollPosition() != _loc2_)
  299.       {
  300.          this.__set__scrollPosition(_loc2_);
  301.          var _loc4_ = mode >= 0 ? this.plusMode : this.minusMode;
  302.          this.dispatchScrollEvent(inc + _loc4_);
  303.       }
  304.    }
  305.    function startTrackScroller(Void)
  306.    {
  307.       this._parent.pressFocus();
  308.       if(this._parent.scrollTrackDownName.length > 0)
  309.       {
  310.          if(this._parent.scrollTrackDown_mc == undefined)
  311.          {
  312.             this._parent.setSkin(mx.controls.scrollClasses.ScrollBar.skinIDTrackDown,this.scrollTrackDownName);
  313.          }
  314.          else
  315.          {
  316.             this._parent.scrollTrackDown_mc.visible = true;
  317.          }
  318.       }
  319.       this._parent.trackScroller();
  320.       this._parent.scrolling = setInterval(this._parent,"scrollInterval",this.getStyle("repeatDelay"),"Page",-1);
  321.    }
  322.    function scrollInterval(inc, mode)
  323.    {
  324.       clearInterval(this.scrolling);
  325.       if(inc == "Page")
  326.       {
  327.          this.trackScroller();
  328.       }
  329.       else
  330.       {
  331.          this.scrollIt(inc,mode);
  332.       }
  333.       this.scrolling = setInterval(this,"scrollInterval",this.getStyle("repeatInterval"),inc,mode);
  334.    }
  335.    function trackScroller(Void)
  336.    {
  337.       if(this.scrollThumb_mc._y + this.scrollThumb_mc.__get__height() < this._ymouse)
  338.       {
  339.          this.scrollIt("Page",1);
  340.       }
  341.       else if(this.scrollThumb_mc._y > this._ymouse)
  342.       {
  343.          this.scrollIt("Page",-1);
  344.       }
  345.    }
  346.    function dispatchScrollChangedEvent(Void)
  347.    {
  348.       this.dispatchEvent({type:"scrollChanged"});
  349.    }
  350.    function stopScrolling(Void)
  351.    {
  352.       clearInterval(this._parent.scrolling);
  353.       this._parent.scrollTrackDown_mc.visible = false;
  354.    }
  355.    function releaseScrolling(Void)
  356.    {
  357.       this._parent.releaseFocus();
  358.       this.stopScrolling();
  359.       this._parent.dispatchScrollChangedEvent();
  360.    }
  361.    function trackOver(Void)
  362.    {
  363.       if(this._parent.scrollTrackOverName.length > 0)
  364.       {
  365.          if(this._parent.scrollTrackOver_mc == undefined)
  366.          {
  367.             this._parent.setSkin(mx.controls.scrollClasses.ScrollBar.skinIDTrackOver,this.scrollTrackOverName);
  368.          }
  369.          else
  370.          {
  371.             this._parent.scrollTrackOver_mc.visible = true;
  372.          }
  373.       }
  374.    }
  375.    function trackOut(Void)
  376.    {
  377.       this._parent.scrollTrackOver_mc.visible = false;
  378.    }
  379.    function onUpArrow(Void)
  380.    {
  381.       this._parent.scrollIt("Line",-1);
  382.    }
  383.    function onDownArrow(Void)
  384.    {
  385.       this._parent.scrollIt("Line",1);
  386.    }
  387.    function onScrollChanged(Void)
  388.    {
  389.       this._parent.dispatchScrollChangedEvent();
  390.    }
  391. }
  392.