The Rectangle Class
The Flash Player now contains a lot of new feature exposed to ActionScript that require Rectangles to be specified so Macromedia also added a new ActionScript class for us in this release that makes it really easy for developers to define and manipulate Rectangles. This class is therefore conveniently named the Rectangle class and we can use it to specify the scrollRect of a movie clip as opposed to using a simple object, like this:

squareMask = new flash.geom.Rectangle(0,0,100,100)
//define the viewing area and scroll offset
scrollingMovieclip.scrollRect=squareMask
//add the square mask

I recommend that you use an instance of the Rectangle class to specify the scrollRect of a movie clip as opposed to a simple object, simply because it allows a lot more control over the rectangle once you have created it.

If you are going to be creating a lot of instances of the Rectangle class in your ActionScript, then you should import the Rectangle class namespace using the import statement, it will make your life a lot easier because you wont have to constantly type the full path to the Rectangle class, which is located in the flash.geom package:

import flash.geom.Rectangle
squareMask = new Rectangle(0,0,100,100)
scrollingMovieclip.scrollRect=squareMask

The Rectangle class constructor accepts four parameters; x, y, width and height.

flash.geom.Rectangle(x,y,width,height)

The first two parameters (x and y) define the position of the top left corner. Then the last two parameters (width and height) define the actual size of the rectangle. When you use an instance of the Rectangle class to set the scrollRect property of a movie clip, the x and y parameters are used as the scrolling offsets for each axis.

Once you have created an instance of the Rectangle class, you then have yourself an object that contains more than just the four properties required of an object passed to the scrollRect property. There are numerous other properties and methods that you can use to find out about or manipulate that rectangle object, for example to move the top left hand corner of the rectangle you can use the Rectangle.offset method:

import flash.geom.Rectangle
squareMask = new Rectangle(0,0,100,100)
squareMask.offset(10,10)
trace(squareMask)
scrollingMovieclip.scrollRect=squareMask

Or to change the width of the rectangle you can just set the value of the width property:

import flash.geom.Rectangle
squareMask = new Rectangle(0,0,100,100)
squareMask.width+=100
//add 100 pixels to the width of the rectangle
scrollingMovieclip.scrollRect=squareMask

Also, you can for example, find out the position of the bottom right hand corner of the rectangle using the bottomRight property:

import flash.geom.Rectangle
squareMask = new Rectangle(0,0,100,100)
bottomRight=squareMask.bottomRight
trace(bottomRight)

Scrolling Large Amounts of Text
So far, I have only shown you how to use the scrollRect property to crop a rectangular region of a movie clip and hide the rest, however, the real power of this feature comes into play when we actually need to scroll the movie clip's content around.

I am now going to show you a fairly simple example of how to use the scrollRect property to scroll some text, loaded from a text file. For added effect we will add some blur to the text while it is scrolling and a little inertia, just because we can.

1. First and foremost create a new Flash Document.
2. Set the movie's width and height to something reasonable (370 * 200) works for me.
3. Rename the first and only layer on the timeline to actions.
4. Select the first frame on the actions layer and open the Actions panel (F9).
5. Add the following code:

   import flash.geom.Rectangle
   import flash.filters.BlurFilter
   /*

   Ensure that the Flash Movie can only be resized along the x and yaxis

   */
   Stage.addListener(this)
   Stage.align="TL"
   Stage.scaleMode="noScale"
   blur=new BlurFilter(0,0,3)
   //create a blur filter and store a reference to it
   sRect=new Rectangle(0,0,w,h)
   //create a rectangle with no scrolling offset and store a reference to it onResize()
   //resize the textfield and scrollRect to the size of the Stage
   initialize()
   //create a textfield inside of a movie clip
   */
   load the contents of the specified text file into the textfield
   */
   loadTextFile("desiderata.txt")

6. Create a new text file and put some content inside it, the more the merrier.
7. Save the text file in a new folder and remember the text files name.
8. Select the first frame of the actions layer again.
9. Open the Actions panel, if it is not already open. (F9).
10. Change the last line of code that looks like this:

    loadTextFile("desiderata.txt")

11. Replace "desiderata.txt" with the name of your text file.
12. Now add a new layer above the layer named actions.
13. Rename the new layer to functions.
14. Select the first frame of the functions layer.
15. Open the Actions panel, if it is not already open. (F9).
16. Add the following code:

    import mx.utils.Delegate
    //create a textfield inside a movie clip
    function initialize()
    {
    //create a container movie clip because you cant use scrollRect on a textfield
    c=this.createEmptyMovieClip("container_mc",this.getNextHighestDepth())
    //create a textfield inside the container movieclip
    c.createTextField("contents_txt",c.getNextHighestDepth(),0,0,w,h)
    //store a short reference to the textfield
    tf=c.contents_txt
    //set the initial textfield properties
    with(tf)
    {
    multiline=true
    wordWrap=true
    selectable=false
    html=true
    condenseWhite=true
    autoSize=true
    }
    //specify the default scrollRect
    c.scrollRect=sRect
    }
    //called each frame to scroll the text into view with some intertia
    function scroll()
    {
    //how far away is the current scroll away from the target scroll
    var diff=Math.round(tysRect.y)
    //if the difference is negative, make it positive
    if(diff<1)
    diff*=1
    //if the difference is too big, limit it to 10
    if(diff>10) diff=10
    //update the blur on the yaxis
    blur.blurY=diff
    //add a percentage of the distance we need to go to the yaxis
    scroll offset
    sRect.y+=(tysRect.y)/8
    //if the text has scrolled to where it is supposed to be, stop calling this function
    if(Math.round(tysRect.y) == 0) delete c.onEnterFrame
    //reapply the changed scrollRect and blur filter
    c.scrollRect=sRect
    c.filters=[blur]
    }
    //loads a textfiles contents into the textfield
    function loadTextFile(url)
    {
    //show a message while we wait for the file to load
    tf.htmlText="Loading... please wait"
    var txt=new LoadVars()
    //hotwire
    the onData event to set the contents of the textfield
    txt.onData=function(d)
    {
    tf.htmlText=d
    }
    //load the specified file
    txt.load(url)
    }
    //called when the mouse moves
    function onMouseMove()
    {
    //set the target position
    ty=(this._ymouse)/200*(tf._heighth)
    
    //call the 'scroll' function every frame
    c.onEnterFrame=Delegate.create(this,scroll)
    }
    //called when the Stage resizes
    function onResize()
    {
    //resize the textfield and the scrollRect
    tf._width=sRect.width=Stage.width
    tf._height=sRect.height=Stage.height
    w=Stage.width
    h=Stage.height
    }

17. Now save the Flash Document (CTRL + S) in the same directory as the text file you created. 18. Test your Flash Movie (CTRL + ENTER). You should see a text field that is the same size as the Stage, containing the text from your text file. When you move your mouse up, the text scrolls down, when you move your mouse down, the text scrolls up. Try resizing the window, the text field should resize.

Even Faster Scrolling with Bitmap Caching
Although this feature can be used independently of Bitmap Caching, it is necessary to turn on Bitmap Caching for movie clips that have a scrollRect property defined, to achieve maximum performance when scrolling. This is because it is much faster for the player to shift around pixels in the bitmap equivalent of the movie clip that was generated by Bitmap Caching, than it is to copy around the vector data of a movie clip.

Using scrollRect to overcome size limits Previously I mentioned that bitmaps inside the player cannot be large than 2880 pixels in either width or height. This can become a problem when you want to apply a filter to a movie clip that is larger than thesedimensions. When you apply a filter to a movie clip, Bitmap Caching is turned on for that movie clip so that abitmap representation of it is generated internally. The filter is then applied to the bitmap representation that is generated.

Let's say for example that you have one large movie clip that is 5000 pixels in width and you want toscroll it across the background of your Flash Movie with a blur filter applied. Unfortunately you cannot simplyapply the filter to the movie clip because a bitmap cannot be generated internally to represent the movie clip,due to the fact that its dimensions are larger than the size limits. However you can work around this problem using the scrollRect property. I think it would be safe to say that your actual Flash Movie will not be 2880 pixels or more in width. So, all you need to do is set the scrollRect property of the scrolling movie clip to crop it to the size of the Flash Movie which makes the visual size of the movie clip smaller than the maximum size limit. Filters are applied last, so the filters you specified either in the authoring environment or using ActionScript will be applied to the movie clip's cropped state:

largeMovieclip.scrollRect=new flash.geom.Rectangle
(0,0,Stage.width,Stage.height)
blur=new flash.filters.BlurFilter(3,0,3)
// a Gaussian blur on the x axis
largeMovieclip.filters=[blur]

• Figure 1
• Figure 2
• Figure 3
• Figure 4
• Figure 5
• Figure 6