The problem lies in a small javascript file: brwsniff.js, a handy dandy browser sniffer that checks for the installed Flash Player version number. The bit of code written for non-IE browsers wasn’t expecting a player with a version number of more than one digit; so, seeing only the one’s place digit, if you’ve got Flash Player 10 installed, the script comes up with a version number of ZERO!

Unfortunately, the author of this otherwise delightful script has not updated the file since before Flash Player 10 was released. Having made the minor repair necessary, I’m making my updated version available for download HERE.

Please note: If for some reason you needed this script to detect the browser software in use, I’m afraid you’re still out of luck. The script seems to see everything as either IE or Firefox.

[UPDATE]
Got a message from Pau Garcia i Quiles, author of jsbrwsniff.  He’ll publish a bugfix soon—until he does, download the version posted here.  I’ll announce when an official bug fix becomes available.  New features he’s planning to add in the coming months:

A tiny object being masked by a huge shape will cause getBounds() to return the extents of… the mask, not the visible object.  It gets even better if your object happens to move beyond the masked area–thus making it totally invisible.  Now getBounds() exapands to include the area of the giant mask plus that of the tiny object, which is no longer being drawn to the screen at all.

In fact, there appears to be no built-in method for reliably determining the actual screen area a MovieClip is occupying.  Do we call this a bug, or was it really meant to work this way???

I decided to try writing a handy dandy function to remedy this problem, and in so doing discovered another serious limitation involving masks.  When you create an arrangement of layers in the Flash IDE with, let’s say three or four objects being masked by one mask, you’ve done something that apparently is only possible with the Flash IDE, and not with AS3.  If you have a look at the .mask property of each of those masked objects, they’ll all be set to NULL.  There’s no sign of any masking going on, as far as ActionScript is concerned.  Suppose you manually set the .mask property of one of those three or four masked objects?  The result is that all the other objects will be unmasked.  Using the .mask property strictly pairs one mask to one display object.  So now you’ve got to find a way of duplicating your mask, so each object has its own mask…! 

Well, nonetheless I wrote my own routine: getVisibility() which reliably tracks down whatever is actually visible, and nothing more.  It’s reliable, that is, as long as you manually set your masks in code–one mask for each object.  If a better solution exists, I’d like to know about it.  For now, here’s a little demo of my function versus AS3’s native functions…

(Please open the article to see the flash file or player.)

There’s only one error I can detect in the result of getVisibility() …When objects are rotated, their visibility is based upon a rotated bounding box, rather than the precise shape of the object.  Still, this gets us considerably closer to a solution.

The .fla can be downloaded HERE.  Here’s the code for my getVisibility() function…

function getVisibility(obj:DisplayObject):Rectangle {
 
	var vis:Rectangle;
 
	if (obj.parent == null) return new Rectangle();
 
	if (obj is DisplayObjectContainer) {
		vis = getChildVisibility(obj, obj.parent);
	} else {
		vis = obj.getBounds(obj.parent);
	}
 
	// Is the DisplayObject masked?
	if (obj.mask != null) {
		vis = vis.intersection(obj.mask.getBounds(obj.parent));
	}
 
	// Is the DisplayObject partly or completely off-stage?
	vis = vis.intersection(obj.stage.getBounds(obj.parent));
 
	return vis;
}
 
function getChildVisibility(obj:*, target:DisplayObjectContainer):Rectangle {
 
	var vis:Rectangle = new Rectangle();
	var child:DisplayObject;
	var childRect:Rectangle;
	var i:uint;
 
	for (i = 1; i <= obj.numChildren; i++) {
		child = obj.getChildAt(i-1);
 
		if (child != null) {
			if (child.visible) {
				if (child is DisplayObjectContainer) {
					childRect = getChildVisibility(child, target);
				} else {
					childRect = child.getBounds(target);
				}
				if (child.mask != null) {
					childRect = childRect.intersection(child.mask.getBounds(target));
				}
				vis = vis.union(childRect);
			}
		}
	}
	return vis;
}