And while I’m still in the subject, here’s a final example of how one can use getter/setters do add some functionality that doesn’t normally exist in a MovieClip: altering the registration point of a MovieClip.

This is some commonly requested functionality. There are several libraries out there that do the trick, I suppose, but a long time ago, during my first AS3 project, none of them worked the way I wanted to, so I had to build my own.

It works like this: the Class PointMovieClip – again, by lack of a better name – has two new properties, registrationX and registrationY. These define where the display object’s axis is located (inside its own coordinate space), and obviously, default to 0, 0. If you change them, it’s as if you changed the registration point.

// Moves the registration point of an object 10 pixels down and to the right from its original position
myPMC.registrationX = 10;
myPMC.registrationY = 10;

// Rotates the object from the new position
myPMC.rotation = 45;

The interesting thing about this example is that it works by overriding existing properties such as x and y, and adding some additional functionality to rotation, scaleX and scaleY. The getter/setters, in this case, are intercepting the user’s changes to those values and making it act accordingly, so other than adding registrationX and registrationY, it’s maintaining the same MovieClip API, but adding new functionality to it.

package com.zehfernando.display {
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.geom.Point;	

	/**
	 * @author Zeh Fernando
	 */
	public class PointMovieClip extends MovieClip {

		// Instance properties ----------------------------------------------------------------

		protected var _registrationX:Number;		// Registration point X
		protected var _registrationY:Number;		// Registration point Y
		protected var _x:Number;					// User-defined X
		protected var _y:Number;					// User-defined Y

		protected var setToUpdate:Boolean;			// Whether this instance is already set to update on the next Event.RENDER

		// ================================================================================================================
		// CONSTRUCTOR ----------------------------------------------------------------------------------------------------

		public function PointMovieClip() {
			super();
			
			// Reads the current __values to keep them
			_x = super.x;
			_y = super.y;
			_registrationX = 0;
			_registrationY = 0;
			fixPosition();
		}

		// ================================================================================================================
		// INTERNAL INSTANCE functions ------------------------------------------------------------------------------------

		protected function fixPosition(): void {
			// Using localToGlobal/globalToLocal is less precise than doing it mathematically, but the end result is more accurate inside Flash because it's in sync with Flash's positioning and rotating limitations
			var op:Point = new Point(0, 0);
			var rp:Point = new Point(_registrationX, _registrationY);
			rp = parent.globalToLocal(localToGlobal(rp));
			op = parent.globalToLocal(localToGlobal(op));
			super.x = _x - (rp.x - op.x);
			super.y = _y - (rp.y - op.y);
		}

		protected function requestPositionFix(): void {
			if (Boolean(stage) && !setToUpdate) {
				setToUpdate = true;
				stage.addEventListener(Event.RENDER, onRender, false, 0, true);
				stage.invalidate();
			}
		}

		// ================================================================================================================
		// EVENT functions ------------------------------------------------------------------------------------------------

		protected function onRender(e:Event): void {
			stage.removeEventListener(Event.RENDER, onRender);
			setToUpdate = false;
			fixPosition();
		}

		// ================================================================================================================
		// ACCESSOR functions ---------------------------------------------------------------------------------------------

		override public function get x(): Number {
			return _x;
		}
		override public function set x(__value:Number): void {
			_x = __value;
			requestPositionFix();
		}

		override public function get y(): Number {
			return _y;
		}
		override public function set y(__value:Number): void {
			_y = __value;
			requestPositionFix();
		}

		override public function set rotation(__value:Number): void {
			super.rotation = __value;
			requestPositionFix();
		}
		override public function set scaleX(__value:Number): void {
			super.scaleX = __value;
			requestPositionFix();
		}
		override public function set scaleY(__value:Number): void {
			super.scaleY = __value;
			requestPositionFix();
		}

		public function get registrationX(): Number {
			return _registrationX;
		}
		public function set registrationX(__value:Number): void {
			_registrationX = __value;
			requestPositionFix();
		}

		public function get registrationY(): Number {
			return _registrationY;
		}
		public function set registrationY(__value:Number): void {
			_registrationY = __value;
			requestPositionFix();
		}

	}
}

One last note: with this class, changing the registration point’s X and Y will move the object around, as it keeps the previous x and y positions instead of offsetting them to match; this is something I actually needed in my implementation as there were moments I tweened that value (together with x, y and rotation – basically, sliding, rotating rectangles on screen) and wanted the object to respond accordingly in a smooth fashion.

While there may be moments one needs to rotate a display object from a given point with the x and y changing immediately to match, I believe the above implementation to work better when animating things across screen.