[F8] What's wrong with my rectangle?

[Q__Hybrid]

First off, it's embarrassing to even post this considering how simple it is to code, but it just isn't working and I don't know why.

The goal: uniformly change the scale of a rectangle relative to its center point.

The problem: application of scalar value to rectangle dimensions creates unexpected dimensions. You'll see what I'm talking about if you have the test window maximized at 100% magnification.

Note: The problem has persisted even after converting everything to Point and Matrix classes. Thanks in advance.

Class code:

// Inside ViewPort.as ...

// import the classes we need to build this custom object
import flash.geom.Point
import flash.geom.Rectangle
import flash.geom.Matrix

/*	Class:		ViewPort
 *	Version:	1.0.1
 *	Desc:			A custom class designed to view a nested movieclip
 *						through a positionable and scalable scrollRect.
 *
 *	NOTES:
 *						- This is intended to serve as the clipping region of
 *							a game engine.
 *						- The MovieClip "backBuffer_mc" is a container that holds
 *							a level map, while "frontBuffer_mc" is assigned the
 *							Rectangle "view."
 *						- "backBuffer_mc" is nested within "frontBuffer_mc".
 *						- The position of "view" is translated, then "view" is
 *							re-applied to "frontBuffer_mc" to achieve camera tracking.
 *						-	Zoom effects are achieved by scaling "view" before
 *							translation, then increasing the _xscale and _yscale
 *							of "frontBuffer_mc" to preserve the original dimensions
 *							of "view".
 */
class ViewPort {
	/*	Class Properties			*/
	private static var frontBufferDepth:Number = 1;		//	place the clipping layer above the level map layer
	private static var backBufferDepth:Number = 0;		//	place the level map layer below the clipping layer
	/*	Instance Properties		*/
	private var scaleMatrix:Matrix;							// 1. scale is always applied first
	private var translateMatrix:Matrix;					// 2. translation is always applied second
	private var viewSize:Object;								//	initial width and height of rectangle
	private var viewTL_In:Point;								//	default position of top-left corner of rectangle
	private var viewBR_In:Point;								//	default position of bottom-right corner of rectangle
	private var viewTL_Out:Point;								//	scaled, translated top-left corner of rectangle
	private var viewBR_Out:Point;								//	scaled, translated bottom-right corner of rectangle
	private var viewCenter:Point;								//	centerpoint of the rectangle
	private var viewScale:Number = 1;						//	scale of the rectangle
	private var viewInverse:Number = 1;					//	_xscale, _yscale used to preserve rectangle
	private var viewZoomStep:Number = 0;				//	value ranging from 0 to (2 * Math.PI)
	private var view:Rectangle;									//	the clipping rectangle
	private var target_mc:MovieClip;						//	the layer that is loading this instance
	private var frontBuffer_mc:MovieClip;				//	the clipping layer
	private var backBuffer_mc:MovieClip;				//	the level map layer
	private var targetDepth:Number;							//	depth target_mc is loading our instance into
	public function ViewPort(t:MovieClip, d:Number, s:String, x:Number, y:Number, w:Number, h:Number) {
		/*	Constructor		*/
		
		//	a nested argument checking function will
		//	be inserted here and will conditionally init
		//	the class, otherwise abort.
		
		initProperties(t, d, s, x, y, w, h);
	}
	private function initProperties(t:MovieClip, d:Number, s:String, x:Number, y:Number, w:Number, h:Number):Void {
		moveView(x, y);				//	center our view
		setViewSize(w, h);		//	size the view (at 100% zoom)
		defineViewRect();			//	create the rectangle of our view
		setTargetDepth(d);		//	store the depth our instance is loading into
		buildViewPort(t);			//	create our instance on the layer that is loading it
		clipRender();					//	apply scrollRect to frontBuffer_mc
		loadSurface(s);				//	load a graphic to test the behavior of the class.
	}
	private function setTargetDepth(d:Number):Void {
		targetDepth = d;
	}
	private function buildViewPort(t:MovieClip, d:Number):Void {
		buildFrontBuffer(t);
		buildBackBuffer();
	}
	private function buildFrontBuffer(t:MovieClip):Void {
		frontBuffer_mc = t.createEmptyMovieClip("frontBuffer_mc", frontBufferDepth);
	}
	private function buildBackBuffer():Void {
		backBuffer_mc = frontBuffer_mc.createEmptyMovieClip("backBuffer_mc", backBufferDepth);
	}
	private function moveView(x:Number, y:Number):Void {
		viewCenter = new Point(x, y);
	}
	private function setViewSize(newW:Number, newH:Number):Void {
		var newSize:Object = {width : newW, height : newH};
		viewSize = newSize;
		
		/*	Important		*/	//	<= = = = = = = = = = = = = = = = = = = = = = =
		
		//	"viewCenter" needs to rest at the center of "view",
		//	so place top-left corner of "view" at a negative value
		//	relative to "viewCenter" and place bottom-right corner of
		//	"view" at a positive value relative to "viewCenter"
		
		viewTL_In = new Point(-(viewSize.width / 2), -(viewSize.height / 2));
		viewBR_In = new Point((viewSize.width / 2), (viewSize.height / 2));
	}
	private function buildMatrices():Void {
		scaleMatrix = new Matrix(1, 0, 0, 1, 0, 0);
		translateMatrix = new Matrix(1, 0, 0, 1, 1, 1);
	}
	private function defineViewRect():Void {
		
		/*	Error ?		*/	//	< = = = = = = = = = = = = = = = = = = = = = = = = =
		
		//	Is this where the error is?

		buildMatrices();
		scaleMatrix.scale(viewScale, viewScale);
		translateMatrix.translate(viewCenter.x, viewCenter.y);
		scaleMatrix.concat(translateMatrix);
		
		viewTL_Out = scaleMatrix.transformPoint(viewTL_In);
		viewBR_Out = scaleMatrix.transformPoint(viewBR_In);
	}
	private function buildView():Void {
		view = new Rectangle(viewTL_Out.x,
												 viewTL_Out.y,
												 viewBR_Out.x,
												 viewBR_Out.y);
	}
	private function refreshView():Void {
		clipRender();
	}
	private function loadSurface(i:String):Void {
		backBuffer_mc.loadMovie(i);
	}
	private function clipRender():Void {
		frontBuffer_mc.scrollRect = view;
	}
	private function preserveFullSize():Void {
		viewInverse = (1 / viewScale) * 100;
		frontBuffer_mc._xscale = frontBuffer_mc._yscale = viewInverse;
	}
	public function zoomView():Void {
		/*	Error ?		*/	//	< = = = = = = = = = = = = = = = = = = = = = = = =
		
		// Is this where the error is?
		
		var zoomOrigin:Number = 0.75;
		var zoomAmplitude:Number = 0.25;
		var zoomX:Number = 320 + (Math.cos(viewZoomStep * 4) * 30);
		var zoomY:Number = 240 + (Math.sin(viewZoomStep * 4) * 30);
		viewScale = zoomOrigin + (Math.cos(viewZoomStep) * zoomAmplitude);
		moveView(zoomX, zoomY);
		defineViewRect();
		buildView();
		refreshView();
		preserveFullSize();
		if(viewZoomStep == (Math.PI * 2)) {
			viewZoomStep = 0;
		} else {
			viewZoomStep += (Math.PI / 180);
		}
		//debugVars();
	}
	private function debugVars():Void {
		/*	Debugger	*/
		
		// use this to spit out vars
		for(var p:String in this) {
			if(p.indexOf("view", 0) != (-1) || p.indexOf("Matrix") != (-1)) {
				trace(p + " = " + this[p]);
			}
		}
	}
}

Flash document code:

// Set your document to 640 x 480, background #639A9C
// in Layer 1, Frame 1 of the main timeline...

var myImage:String;		// supply the path of a local image of your choosing
var testRender:ViewPort = new ViewPort(this, 0, myImage, 320, 240, 640, 480);
this.onEnterFrame = function () {
	testRender.zoomView();
};

[Thomas D.Garrod]

Wow. I am not surprised you had few responses. That looks pretty complicated. I am trying to figure out how to use the scrollRec myself. Did you ever get yours to work?

I often post and get no response. I post my own answers, when I find them, just so others can look them up. Oddly, I find this community and many others to be knowlegable within very strict boundaries. Based on the paucity of response, it seems you went outside those boundaries when you asked a difficult question about something new. This new scrollRect functionality looks promising.

By now, I'm guessing you know the answer to your question. I hope you will add to your own post. I would be interested in hearing from you.

[TheProudMonkey]

I'm afraid that what you're doing is a bit above me as I've never had to implement many of the functions and methods that you are using. However, I would like to echo Thomas' sentiment about stepping outside of the boundaries so many here observe. I've posted questions about code containing highschool geometry and people avoided them like the plague. Good luck and kudos.

[mneil]

I haven't tested it but I think it might be better to point out the part of your class that actually deals with the scaling. I know your using matrices but I don't feel like running through n lines of code to find the spot. I'm sure some of it is useful but please be more specific. I'm sure there is already a class out there like this; have you searched for another?

PS, is _xscale= ? not specific enough that you have to result to matrices. Cant you set the registration in the center and scale that way?