/nickro/greensock/transform/TransformManager.as

Large files files are truncated, but you can click here to view the full file

/**

 * VERSION: 1.887

 * DATE: 2010-04-27

 * AS3

 * UPDATES AND DOCUMENTATION AT: http://www.greensock.com/transformmanageras3/

 **/

package org.nickro.greensock.transform {

        import org.nickro.greensock.events.TransformEvent;

        import org.nickro.greensock.transform.utils.MatrixTools;



        import flash.display.DisplayObject;

        import flash.display.DisplayObjectContainer;

        import flash.display.Graphics;

        import flash.display.Shape;

        import flash.display.Sprite;

        import flash.display.Stage;

        import flash.events.Event;

        import flash.events.EventDispatcher;

        import flash.events.KeyboardEvent;

        import flash.events.MouseEvent;

        import flash.geom.Matrix;

        import flash.geom.Point;

        import flash.geom.Rectangle;

        import flash.text.TextField;

        import flash.ui.Keyboard;

        import flash.ui.Mouse;

        import flash.utils.Dictionary;

        import flash.utils.getDefinitionByName;

        import flash.utils.getTimer;

/**

 * TransformManager makes it easy to add interactive scaling/rotating/moving of DisplayObjects to your Flash

 * or Flex application. It uses an intuitive interface that's similar to most modern drawing applications.

 * When the user clicks on a managed DisplayObject, a selection box will be drawn around it along with 8 handles

 * for scaling/rotating. When the mouse is placed just outside of any of the scaling handles, the cursor will

 * change to indicate that they're in rotation mode. Just like most other applications, the user can hold down

 * the SHIFT key to select multiple items, to constrain scaling proportions, or to limit the rotation to

 * 45 degree increments.<br /><br />

 *

 * <b>FEATURES INCLUDE:</b><br />

 * <ul>

 *       <li> Select multiple items and scale/rotate/move them all simultaneously. </li>

 *       <li> Includes a <code>FlexTransformManager</code> class that makes it simple to integrate into Flex applications.</li>

 *       <li> Perform virtually any action (transformations, selections, etc.) through code.</li>

 *       <li> Depth management which allows you to programmatically push the selected items forward or backward in the stacking order</li>

 *       <li> Set minScaleX, maxScaleX, minScaleY, and maxScaleY properties on each item </li>

 *       <li> Arrow keys move the selection </li>

 *       <li> You can set the scaleMode of any TransformItem to SCALE_WIDTH_AND_HEIGHT so that the width/height properties are altered instead of scaleX/scaleY. This can be helpful for text-related components because altering the width/height changes only the container's dimensions while retaining the text's size.</li>

 *       <li> There is a 10-pixel wide draggable edge around around the border that users can drag. This is particularly helpful with TextFields/TextAreas.</li>

 *       <li> Define bounds within which the DisplayObjects must stay, and TransformManager will not let the user scale/rotate/move them beyond those bounds</li>

 *       <li> Automatically bring the selected item(s) to the front in the stacking order </li>

 *       <li> The DELETE and BACKSPACE keys can be used to delete the selected DisplayObjects </li>

 *       <li> Lock certain kinds of transformations like rotation, scale, and/or movement </li>

 *       <li> Lock the proportions of the DisplayObjects so that users cannot distort them when scaling</li>

 *       <li> Scale from the DisplayObject's center or from its corners</li>

 *       <li> Listen for Events like SCALE, MOVE, ROTATE, SELECTION_CHANGE, DEPTH_CHANGE, CLICK_OFF, FINISH_INTERACTIVE_MOVE, FINISH_INTERACTIVE_SCALE, FINISH_INTERACTIVE_ROTATE, DOUBLE_CLICK, and DESTROY </li>

 *       <li> Set the selection box line color and handle thickness</li>

 *       <li> Cursor will automatically change to indicate scale or rotation mode</li>

 *       <li> Optionally hide the center handle</li>

 *       <li> Export transformational data for each item's scale, rotation, and position as well as the TranformManager's settings in XML format so that you can easily save it to a database (or wherever). Then apply it anytime to revert objects to a particular state.</li>

 *       <li> VERY easy to use. In fact, all it takes is one line of code to get it up and running with the default settings. </li>

 * </ul>

 *

 * <b>NOTES / LIMITATIONS</b>:<br />

 * <ul>

 *              <li> All DisplayObjects that are managed by a particular TransformManager instance must have the same parent (you can create multiple TransformManager instances if you want)</li>

 *              <li> TextFields cannot be flipped (have negative scales).</li>

 *              <li> TextFields cannot be skewed. Therefore, when a TextField is part of a multi-selection, scaling will be disabled because it could skew the TextField (imagine if a TextField is at a 45 degree angle, and then you selected another item and scaled vertically - your TextField would end up getting skewed).</li>

 *              <li> Due to several bugs in the Flex framework (acknowledged by Adobe), TransformManager doesn't work quite as expected inside Flex containers, but I created a FlexTransformManager class that helps avoid the limitations. However, you still cannot scale TextFields disproportionately.</li>

 *              <li> Due to a limitation in the way Flash reports bounds, items that are extremely close or exactly on top of a boundary (if you define bounds) will be moved about 0.1 pixel away from the boundary when you select them. If an item fills the width and/or height of the bounds, it will be scaled down very slightly (about 0.2 pixels total) to move it away from the bounds and allow accurate collision detection.</li>

 * </ul>

 *

 * <b>USAGE</b><br /><br />

 *

 * The first (and only) parameter in the constructor should be an object with any number of properties.

 * This makes it easier to set only the properties that shouldn't use their default values (you'll

 * probably find that most of the time the default values work well for you). It also makes the code

 * easier to read. The properties can be in any order, like so:<br /><br /><code>

 *

 *              var manager:TransformManager = new TransformManager({targetObjects:[mc1, mc2], forceSelectionToFront:true, bounds:new Rectangle(0, 0, 550, 450), allowDelete:true});<br /><br /></code>

 *

 * All TransformEvents have an "items" property which is an Array populated by the affected TransformItem instances. TransformEvents also have a "mouseEvent" property that will be populated if there was an associted MouseEvent (like CLICK_OFF) <br /><br />

 *

 * <b>EXAMPLES:</b><br /><br />

 *

 * To make two MovieClips (mc1 and mc2) transformable using the default settings:<br /><br /><code>

 *

 *              import org.nickro.greensock.transform.TransformManager; <br /><br />

 *

 *              var manager:TransformManager = new TransformManager({targetObjects:[mc1, mc2]});<br /><br /></code>

 *

 * To make the two MovieClips transformable, constrain their scaling to be proportional (even if the user is not holding

 * down the shift key), call the onScale function everytime one of the objects is scaled, lock the rotation value of each

 * MovieClip (preventing rotation), and allow the delete key to appear to delete the selected MovieClip from the stage:<br /><br /><code>

 *

 *              import org.nickro.greensock.transform.TransformManager;<br />

 *              import org.nickro.greensock.events.TransformEvent;<br /><br />

 *

 *              var manager:TransformManager = new TransformManager({targetObjects:[mc1, mc2], constrainScale:true, lockRotation:true, allowDelete:true, autoDeselect:true});<br />

 *              manager.addEventListener(TransformEvent.SCALE, onScale);<br />

 *              function onScale($e:TransformEvent):void {<br />

 *                      trace("Scaled " + $e.items.length + " items");<br />

 *              }<br /><br /></code>

 *

 * To add mc1 and mc2 and myText after a TransformManager has been created, and then listen for when only mc1 is selected:<br /><br /><code>

 *

 *              import org.nickro.greensock.transform.TransformManager;<br />

 *              import org.nickro.greensock.events.TransformEvent;<br /><br />

 *

 *              var manager:TransformManager = new TransformManager();<br /><br />

 *

 *              var mc1Item:TransformItem = manager.addItem(mc1);<br />

 *              var mc2Item:TransformItem = manager.addItem(mc2);<br />

 *              var myTextItem:TransformItem = manager.addItem(myText, TransformManager.SCALE_WIDTH_AND_HEIGHT, true);<br /><br />

 *

 *              mc1Item.addEventListener(TransformEvent.SELECT, onSelectClip1);<br /><br />

 *

 *              function onSelectClip1($e:TransformEvent):void {<br />

 *                      trace("selected mc1");<br />

 *              }<br /><br /></code>

 *

 *

 * <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/eula.html">http://www.greensock.com/eula.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.

 *

 * @author Jack Doyle, jack@greensock.com

 */

        public class TransformManager extends EventDispatcher {

                public static const VERSION:Number = 1.887;

                public static const SCALE_NORMAL:String = "scaleNormal";

                public static const SCALE_WIDTH_AND_HEIGHT:String = "scaleWidthAndHeight";

                /** @private precomputation for speed **/

                private static const _DEG2RAD:Number = Math.PI / 180;

                /** @private precomputation for speed **/

                private static const _RAD2DEG:Number = 180 / Math.PI;

                /** @private can be scaleCursor or rotationCursor **/

                private static var _currentCursor:Shape;

        /** @private the TransformManager instance that called swapCursorIn() most recently (we need to track this for cases where multiple instances exist - it's possible for a swapCursorOut() to be called by the one releasing control after the swapCursorIn() is called by the one gaining control. **/

                private static var _cursorManager:TransformManager;

        /** @private stores key codes of pressed keys **/

                private static var _keysDown:Object;

        /** @private a Dictionary that gives us a way to look up the stages that have had listeners added to them (to accommodate multi-window AIR apps) **/

                private static var _keyListenerInits:Dictionary = new Dictionary();

                /** @private **/

                private static var _keyDispatcher:EventDispatcher = new EventDispatcher();

                /** @private **/

                private static var _tempDeselectedItem:TransformItem;

                /** @private **/

                public static var scaleCursor:Shape;

                /** @private **/

                public static var rotationCursor:Shape;

                /** @private **/

                public static var moveCursor:Shape;



                /** @private If true, we'll delete a TransformItem's MovieClip when it's selected and the user hits the Delete key. **/

                private var _allowDelete:Boolean;

                /** @private **/

                private var _allowMultiSelect:Boolean;

                /** @private **/

                private var _hideCenterHandle:Boolean;

                /** @private if true, whenever you select an item, it will be ADDED to the selection instead of replacing it.**/

                private var _multiSelectMode:Boolean;

                /** @private used to prevent unnecessary actions when this TransformManager is causing TransformItem events to get dispatched, like when selecting/deselecting multiple items or rotating/scaling/moving **/

                private var _ignoreEvents:Boolean;

                /** @private If true (and it's true by default), TransformItems will be deselected when the user clicks off of them. Disabling this is sometimes necessary in cases where you want the user to be able to select a MovieClip and then select/edit separate form fields without deselecting the MovieClip. In that case, you'll need to handle things in a custom way through your _eventHandler (look for action_str == "deselect" which will still get fired when the user clicks off of it)**/

                private var _autoDeselect:Boolean;

                /** @private If true, only proportional scaling is allowed (even if the SHIFT key isn't held down).**/

                private var _constrainScale:Boolean;

                /** @private **/

                private var _lockScale:Boolean;

                /** @private **/

                private var _scaleFromCenter:Boolean;

                /** @private **/

                private var _lockRotation:Boolean;

                /** @private **/

                private var _lockPosition:Boolean;

                /** @private **/

                private var _arrowKeysMove:Boolean;

                /** @private reflects info about the selection. If any selected items have contrainScale set to true, this will be true.**/

                private var _selConstrainScale:Boolean;

                /** @private reflects info about the selection. If any selected items have lockScale set to true, this will be true.**/

                private var _selLockScale:Boolean;

                /** @private reflects info about the selection. If any selected items have loclRotation set to true, this will be true.**/

                private var _selLockRotation:Boolean;

                /** @private reflects info about the selection. If any selected items have lockPosition set to true, this will be true.**/

                private var _selLockPosition:Boolean;

                /** @private **/

                private var _selHasTextFields:Boolean;

                /** @private if any of the items in the selection have scale limits (minScaleX, maxScaleX, minScaleY, maxScaleY), this should be true.**/

                private var _selHasScaleLimits:Boolean;

                /** @private **/

                private var _lineColor:uint;

                /** @private **/

                private var _handleColor:uint;

                /** @private **/

                private var _handleSize:Number;

                /** @private **/

                private var _paddingForRotation:Number;

                /** @private **/

                private var _selectedItems:Array;

                /** @private **/

                private var _forceSelectionToFront:Boolean;

                /** @private Holds references to all TransformItems that this TransformManager can control (use addItem() to add DisplayObjects)**/

                private var _items:Array;

                /** @private ignore clicks on the DisplayObjects in this list (like form elements, etc.)**/

                private var _ignoredObjects:Array;

                /** @private Set this value to false if you want to disable all TransformItems. Setting it to true will enable them all.**/

                private var _enabled:Boolean;

                /** @private Defines an area that the items are restrained to (according to their parent coordinate system)**/

                private var _bounds:Rectangle;

                /** @private **/

                private var _selection:Sprite;

                /** @private Invisible - mirrors the transformations of the overall selection. We use this to pin the handles in the right spots.**/

                private var _dummyBox:Sprite;

                /** @private **/

                private var _handles:Array;

                /** @private To make lookups faster on cursor rollovers. **/

                private var _handlesDict:Dictionary;

                /** @private the parent of the items (they all must share the same parent!)**/

                private var _parent:DisplayObjectContainer;

                /** @private **/

                private var _stage:Stage;

                /** @private acts like a registration point for transformations**/

                private var _origin:Point;

                /** @private stores various data about the selection during transformations**/

                private var _trackingInfo:Object;

                /** @private Only true after at least one item is added (which gives us a way to get to the stage and set up listeners)**/

                private var _initted:Boolean;

                /** @private **/

                private var _isFlex:Boolean;

                /** @private **/

                private var _edges:Sprite;

                /** @private **/

                private var _lockCursor:Boolean;

                /** @private **/

                private var _onUnlock:Function;

                /** @private **/

                private var _onUnlockParam:Event;

                /** @private **/

                private var _dispatchScaleEvents:Boolean;

                /** @private **/

                private var _dispatchMoveEvents:Boolean;

                /** @private **/

                private var _dispatchRotateEvents:Boolean;

                /** @private while an interactive scale/move/rotation is in progress, this is true.**/

                private var _isTransforming:Boolean;

                /** @private **/

                private var _prevScaleX:Number = 0;

                /** @private **/

                private var _prevScaleY:Number = 0;

                /** @private **/

                private var _lockOrigin:Boolean;

                /** @private **/

                private var _lastClickTime:uint = 0;





                /**

                 * Constructor

                 *

                 * @param $vars An object specifying any properties that should be set upon instantiation, like <code>{items:[mc1, mc2], lockRotation:true, bounds:new Rectangle(0, 0, 500, 300)}</code>.

                 */

                public function TransformManager($vars:Object = null) {

                        if (TransformItem.VERSION < 1.87) {

                                throw new Error("TransformManager Error: You have an outdated TransformManager-related class file. You may need to clear your ASO files. Please make sure you're using the latest version of TransformManager and TransformItem, available from www.greensock.com.");

                        }

                        if ($vars == null) {

                                $vars = {};

                        }

                        init($vars);

                }



                /** @private **/

                protected function init($vars:Object):void {

                        _allowDelete = setDefault($vars.allowDelete, false);

                        _allowMultiSelect = setDefault($vars.allowMultiSelect, true);

                        _autoDeselect = setDefault($vars.autoDeselect, true);

                        _constrainScale = setDefault($vars.constrainScale, false);

                        _lockScale = setDefault($vars.lockScale, false);

                        _scaleFromCenter = setDefault($vars.scaleFromCenter, false);

                        _lockRotation = setDefault($vars.lockRotation, false);

                        _lockPosition = setDefault($vars.lockPosition, false);

                        _arrowKeysMove = setDefault($vars.arrowKeysMove, false);

                        _forceSelectionToFront = setDefault($vars.forceSelectionToFront, true);

                        _lineColor = setDefault($vars.lineColor, 0x3399FF); //Line color (including handles and selection around MovieClip)

                        _handleColor = setDefault($vars.handleFillColor, 0xFFFFFF); //Handle fill color

                        _handleSize = setDefault($vars.handleSize, 8); //Number of pixels the handles should be (square)

                        _paddingForRotation = setDefault($vars.paddingForRotation, 12); //Number of pixels beyond the handles that should be sensitive for rotating.

                        _hideCenterHandle = setDefault($vars.hideCenterHandle, false);

                        _multiSelectMode = _ignoreEvents = false;

                        _bounds = $vars.bounds;

                        _enabled = true;

                        _keyDispatcher.addEventListener("pressDelete", onPressDelete, false, 0, true);

                        _keyDispatcher.addEventListener("pressArrowKey", onPressArrowKey, false, 0, true);

                        _keyDispatcher.addEventListener("pressMultiSelectKey", onPressMultiSelectKey, false, 0, true);

                        _keyDispatcher.addEventListener("releaseMultiSelectKey", onReleaseMultiSelectKey, false, 0, true);

                        _items = $vars.items || [];

                        _selectedItems = [];



                        this.ignoredObjects = $vars.ignoredObjects || [];

                        _handles = [];

                        _handlesDict = new Dictionary();

                        if ($vars.targetObjects != undefined) {

                                addItems($vars.targetObjects);

                        }

                }



                /** @private **/

                protected function initParent($parent:DisplayObjectContainer):void {

                        if (!_initted && _parent == null) {

                                try {

                                        _isFlex = Boolean(getDefinitionByName("mx.managers.SystemManager")); // SystemManager is the first display class created within a Flex application

                                } catch ($e:Error) {

                                        _isFlex = false;

                                }

                                _parent = $parent;

                                for (var i:int = _items.length - 1; i > -1; i--) {

                                        _items[i].targetObject.removeEventListener(Event.ADDED_TO_STAGE, onTargetAddedToStage);

                                }

                                if (_parent.stage == null) {

                                        _parent.addEventListener(Event.ADDED_TO_STAGE, initStage, false, 0, true); //Sometimes in Flex, the parent hasn't been added to the stage yet, so we need to wait so that we can access the stage.

                                } else {

                                        initStage();

                                }

                        }

                }



                /** @private **/

                protected function onTargetAddedToStage($e:Event):void {

                        initParent($e.target.parent);

                }



                /** @private **/

                protected function initStage($e:Event=null):void {

                        _parent.removeEventListener(Event.ADDED_TO_STAGE, initStage);

                        _stage = _parent.stage;

                        initKeyListeners(_stage);

                        _stage.addEventListener(MouseEvent.MOUSE_DOWN, checkForDeselect, false, 0, true);

                        _stage.addEventListener(Event.DEACTIVATE, onReleaseMultiSelectKey, false, 0, true); //otherwise, if the user has the SHIFT key down and they click on another window and then release the key and then click back on this window, it could get stuck in multiselect mode.

                        initSelection();

                        initScaleCursor();

                        initMoveCursor();

                        initRotationCursor();

                        _initted = true;



                        if (_selectedItems.length != 0) {

                                if (_forceSelectionToFront) {

                                        for (var i:int = _selectedItems.length - 1; i > -1; i--) {

                                                bringToFront(_selectedItems[i].targetObject);

                                        }

                                }

                                calibrateConstraints();

                                updateSelection();

                        }

                }



                /**

                 * In order for a DisplayObject to be managed by TransformManger, it must first be added via <code>addItem()</code>. When the

                 * DisplayObject is added, a TransformItem instance is automatically created and associated with the DisplayObject.

                 * If you need to set item-specific settings like minScaleX, maxScaleX, etc., you would set those via the TransformItem

                 * instance. <code>addItem()</code> returns a TransformItem instance, but you can retrieve it anytime with the <code>getItem()</code>

                 * method (just pass it your DisplayObject, like <code>var myItem:TransformItem = myManager.getItem(myDisplayObject)</code>.<br /><br />

                 *

                 * NOTE: If your targetObject isn't an InteractiveObject, it will not receive MouseEvents like clicks and rollovers that trigger

                 * selection, dragging, cursor changes, etc. so user interaction-based actions won't be possible. That may be perfectly

                 * acceptable, though, if you're going to do transformations directly via code.

                 *

                 * @param $targetObject The DisplayObject to be managed

                 * @param $scaleMode Either <code>TransformManager.SCALE_NORMAL</code> for normal scaleX/scaleY scaling or <code>TransformManager.SCALE_WIDTH_AND_HEIGHT</code> if you prefer that TransformManager alters the <code>width</code>/<code>height</code> properties instead.

                 * @param $hasSelectableText If true, this prevents dragging of the object unless clicking on the edges/border or center handle, and allows the DELETE key to be pressed without deleting the object itself. It will also force the scaleMode to <code>TransformManager.SCALE_WIDTH_AND_HEIGHT</code>.

                 * @return TransformItem instance

                 */

                public function addItem($targetObject:DisplayObject, $scaleMode:String="scaleNormal", $hasSelectableText:Boolean=false):TransformItem {

                        if ($targetObject == _dummyBox || $targetObject == _selection) {

                                return null;

                        }

                        var props:Array = ["constrainScale", "scaleFromCenter", "lockScale", "lockRotation", "lockPosition", "autoDeselect", "allowDelete", "bounds", "enabled", "forceSelectionToFront"];

                        var newVars:Object = {manager:this};

                        for (var i:uint = 0; i < props.length; i++) {

                                newVars[props[i]] = this[props[i]];

                        }

                        var existingItem:TransformItem = getItem($targetObject); //Just in case it's already in the _items Array

                        if (existingItem != null) {

                                existingItem.update(null);

                                return existingItem;

                        }

                        newVars.scaleMode = ($targetObject is TextField) ? SCALE_WIDTH_AND_HEIGHT : $scaleMode;

                        newVars.hasSelectableText = ($targetObject is TextField) ? true : $hasSelectableText;

                        var newItem:TransformItem = newItem = new TransformItem($targetObject, newVars);

                        newItem.addEventListener(TransformEvent.SELECT, onSelectItem);

                        newItem.addEventListener(TransformEvent.DESELECT, onDeselectItem);

                        newItem.addEventListener(TransformEvent.MOUSE_DOWN, onMouseDownItem);

                        newItem.addEventListener(TransformEvent.SELECT_MOUSE_DOWN, onPressMove);

                        newItem.addEventListener(TransformEvent.SELECT_MOUSE_UP, onReleaseMove);

                        newItem.addEventListener(TransformEvent.UPDATE, onUpdateItem);

                        newItem.addEventListener(TransformEvent.SCALE, onUpdateItem);

                        newItem.addEventListener(TransformEvent.ROTATE, onUpdateItem);

                        newItem.addEventListener(TransformEvent.MOVE, onUpdateItem);

                        newItem.addEventListener(TransformEvent.ROLL_OVER_SELECTED, onRollOverSelectedItem);

                        newItem.addEventListener(TransformEvent.ROLL_OUT_SELECTED, onRollOutSelectedItem);

                        newItem.addEventListener(TransformEvent.DESTROY, onDestroyItem);



                        _items.push(newItem);

                        if (!_initted) {

                                if ($targetObject.parent == null) {

                                        $targetObject.addEventListener(Event.ADDED_TO_STAGE, onTargetAddedToStage, false, 0, true);

                                } else {

                                        initParent($targetObject.parent);

                                }

                        }

                        return newItem;

                }



                /**

                 * Same as addItem() but accepts an Array containing multiple DisplayObjects.

                 *

                 * @param $targetObjects An Array of DisplayObject to be managed

                 * @param $scaleMode Either <code>TransformManager.SCALE_NORMAL</code> for normal scaleX/scaleY scaling or <code>TransformManager.SCALE_WIDTH_AND_HEIGHT</code> if you prefer that TransformManager alters the <code>width</code>/<code>height</code> properties instead.

                 * @param $hasSelectableText If true, this prevents dragging of the objects unless clicking on the edges/border or center handle, and allows the DELETE key to be pressed without deleting the object itself. It will also force the scaleMode to <code>TransformManager.SCALE_WIDTH_AND_HEIGHT</code>.

                 * @return An Array of corresponding TransformItems that are created

                 */

                public function addItems($targetObjects:Array, $scaleMode:String="scaleNormal", $hasSelectableText:Boolean=false):Array {

                        var a:Array = [];

                        for (var i:uint = 0; i < $targetObjects.length; i++) {

                                a.push(addItem($targetObjects[i], $scaleMode, $hasSelectableText));

                        }

                        return a;

                }



                /**

                 * Removes an item. Calling this on an item will NOT delete the DisplayObject - it just prevents it from being affected by this TransformManager anymore.

                 *

                 * @param $item Either the DisplayObject or the associated TransformItem that should be removed

                 */

                public function removeItem($item:*):void {

                        var item:TransformItem = findObject($item);

                        if (item != null) {

                                item.selected = false;

                                item.removeEventListener(TransformEvent.SELECT, onSelectItem);

                                item.removeEventListener(TransformEvent.DESELECT, onDeselectItem);

                                item.removeEventListener(TransformEvent.MOUSE_DOWN, onMouseDownItem);

                                item.removeEventListener(TransformEvent.SELECT_MOUSE_DOWN, onPressMove);

                                item.removeEventListener(TransformEvent.SELECT_MOUSE_UP, onReleaseMove);

                                item.removeEventListener(TransformEvent.UPDATE, onUpdateItem);

                                item.removeEventListener(TransformEvent.SCALE, onUpdateItem);

                                item.removeEventListener(TransformEvent.ROTATE, onUpdateItem);

                                item.removeEventListener(TransformEvent.MOVE, onUpdateItem);

                                item.removeEventListener(TransformEvent.ROLL_OVER_SELECTED, onRollOverSelectedItem);

                                item.removeEventListener(TransformEvent.ROLL_OUT_SELECTED, onRollOutSelectedItem);

                                item.removeEventListener(TransformEvent.DESTROY, onDestroyItem);

                                for (var i:int = _items.length - 1; i > -1; i--) {

                                        if (item == _items[i]) {

                                                _items.splice(i, 1);

                                                item.destroy();

                                                break;

                                        }

                                }

                        }

                }



                /** Removes all items from the TransformManager instance. This does NOT delete the items - it just prevents them from being affected by this TransformManager anymore. **/

                public function removeAllItems():void {

                        var item:TransformItem;

                        for (var i:int = _items.length - 1; i > -1; i--) {

                                item = _items[i];

                                item.selected = false;

                                item.removeEventListener(TransformEvent.SELECT, onSelectItem);

                                item.removeEventListener(TransformEvent.DESELECT, onDeselectItem);

                                item.removeEventListener(TransformEvent.MOUSE_DOWN, onMouseDownItem);

                                item.removeEventListener(TransformEvent.SELECT_MOUSE_DOWN, onPressMove);

                                item.removeEventListener(TransformEvent.SELECT_MOUSE_UP, onReleaseMove);

                                item.removeEventListener(TransformEvent.UPDATE, onUpdateItem);

                                item.removeEventListener(TransformEvent.SCALE, onUpdateItem);

                                item.removeEventListener(TransformEvent.ROTATE, onUpdateItem);

                                item.removeEventListener(TransformEvent.MOVE, onUpdateItem);

                                item.removeEventListener(TransformEvent.ROLL_OVER_SELECTED, onRollOverSelectedItem);

                                item.removeEventListener(TransformEvent.ROLL_OUT_SELECTED, onRollOutSelectedItem);

                                item.removeEventListener(TransformEvent.DESTROY, onDestroyItem);

                                _items.splice(i, 1);

                                item.destroy();

                        }

                }



                /**

                 * Allows you to have TransformManager ignore clicks on a particular DisplayObject (handy for buttons, color pickers, etc.). The DisplayObject CANNOT be a child of a targetObject

                 *

                 * @param $object DisplayObject that should be ignored

                 */

                public function addIgnoredObject($object:DisplayObject):void {

                        for (var i:uint = 0; i < _ignoredObjects.length; i++) { //first make sure it's not already in the Array

                                if (_ignoredObjects[i] == $object) {

                                        return;

                                }

                        }

                        removeItem($object);

                        _ignoredObjects.push($object);

                }



                /**

                 * Removes an ignored DisplayObject so that its clicks are no longer ignored.

                 *

                 * @param $object DisplayObject that should not be ignored anymore

                 */

                public function removeIgnoredObject($object:DisplayObject):void {

                        for (var i:uint = 0; i < _ignoredObjects.length; i++) {

                                if (_ignoredObjects[i] == $object) {

                                        _ignoredObjects.splice(i, 1);

                                }

                        }

                }



                /** @private **/

                private function onDestroyItem($e:TransformEvent):void {

                        removeItem($e.target);

                }





//---- GENERAL -------------------------------------------------------------------------------------------------------------------------



                /** @private **/

                private function setOrigin($p:Point):void { //Repositions the registration point of the _dummyBox and then calls plotHandles() to redraw the handles

                        if (!_lockOrigin) {

                                _lockOrigin = true; //prevents problems with recursion, particularly in updateSelection() when enforcing the saftey zone

                                _origin = $p;



                                var local:Point = _dummyBox.globalToLocal(_parent.localToGlobal($p));

                                var bounds:Rectangle = _dummyBox.getBounds(_dummyBox);



                                _dummyBox.graphics.clear();

                                _dummyBox.graphics.beginFill(0x0066FF, 1);

                                _dummyBox.graphics.drawRect(bounds.x - local.x, bounds.y - local.y, bounds.width, bounds.height);

                                _dummyBox.graphics.endFill();



                                _dummyBox.x = _origin.x;

                                _dummyBox.y = _origin.y;



                                enforceSafetyZone();



                                for (var i:int = _selectedItems.length - 1; i > -1; i--) {

                                        _selectedItems[i].origin = _origin;

                                }



                                plotHandles();

                                renderSelection();

                                _lockOrigin = false;

                        }

                }



                /** @private **/

                private function enforceSafetyZone():void { //Due to rounding issues in extremely small decimals, a selection can creep slightly over the bounds when the origin and/or selection bounding box is directly on top of one of the edges of the boundaries. This function enforces a 0.1 pixel "safety zone" to avoid that issue.

                        if (_bounds != null) {

                                var locks:Array;

                                var prevLockPosition:Boolean = _selLockPosition;

                                var prevLockScale:Boolean = _selLockScale;

                                _selLockPosition = false;

                                _selLockScale = false;



                                if (!_bounds.containsPoint(_origin)) {

                                        locks = recordLocks();

                                        if (_bounds.left > _origin.x) {

                                                shiftSelection(_bounds.left - _origin.x, 0);

                                        } else if (_bounds.right < _origin.x) {

                                                shiftSelection(_bounds.right - _origin.x, 0);

                                        }

                                        if (_bounds.top > _origin.y) {

                                                shiftSelection(0, _bounds.top - _origin.y);

                                        } else if (_bounds.bottom < _origin.y) {

                                                shiftSelection(0, _bounds.bottom - _origin.y);

                                        }

                                }



                                if (_selectedItems.length != 0) {

                                        if (locks == null) {

                                                locks = recordLocks();

                                        }

                                        if (_handles[0].point == null) {

                                                plotHandles();

                                        }



                                        var b:Rectangle = getSelectionRect();



                                        if (_bounds.width - b.width < 0.2) {

                                                shiftSelectionScale(1 - (0.22 / b.width));

                                        }



                                        b = getSelectionRect();

                                        if (_bounds.height - b.height < 0.2) {

                                                shiftSelectionScale(1 - (0.22 / b.height));

                                        }

                                        if (Math.abs(b.top - _bounds.top) < 0.1) {

                                                shiftSelection(0, 0.1);

                                        }

                                        if (Math.abs(b.bottom - _bounds.bottom) < 0.1) {

                                                shiftSelection(0, -0.1);

                                        }

                                        if (Math.abs(b.left - _bounds.left) < 0.1) {

                                                shiftSelection(0.1, 0);

                                        }

                                        if (Math.abs(b.right - _bounds.right) < 0.1) {

                                                shiftSelection(-0.1, 0);

                                        }



                                }



                                if (locks != null) {

                                        restoreLocks(locks);

                                }

                                _selLockPosition = prevLockPosition;

                                _selLockScale = prevLockScale;



                        }



                        //In order to impose the safe area, we need to make sure the lockPosition and lockScale properties are false. This function records the current values so we can restore them later.

                        function recordLocks():Array {

                                var a:Array = [];

                                for (var i:int = _selectedItems.length - 1; i > -1; i--) {

                                        a[i] = {position:_selectedItems[i].lockPosition, scale:_selectedItems[i].lockScale};

                                }

                                return a;

                        }



                        function restoreLocks($a:Array):void {

                                for (var i:int = $a.length - 1; i > -1; i--) {

                                        _selectedItems[i].lockPosition = $a[i].position;

                                        _selectedItems[i].lockScale = $a[i].scale;

                                }

                        }



                        function shiftSelection($x:Number, $y:Number):void {

                                _dummyBox.x += $x;

                                _dummyBox.y += $y

                                for (var i:int = _selectedItems.length - 1; i > -1; i--) {

                                        _selectedItems[i].move($x, $y, false, false);

                                }

                                _origin.x += $x;

                                _origin.y += $y;

                        }



                        function shiftSelectionScale($scale:Number):void {

                                var o:Point = _origin.clone();

                                _origin.x = _bounds.x + (_bounds.width / 2);

                                _origin.y = _bounds.y + (_bounds.height / 2);

                                var i:int;

                                for (i = _selectedItems.length - 1; i > -1; i--) {

                                        _selectedItems[i].origin = _origin;

                                }

                                scaleSelection($scale, $scale, false);

                                _origin.x = o.x;

                                _origin.y = o.y;

                                for (i = _selectedItems.length - 1; i > -1; i--) {

                                        _selectedItems[i].origin = _origin;

                                }

                                updateSelection();

                        }



                }



                /** @private **/

                protected function onPressDelete($e:Event = null):void {

                        if (_enabled && _allowDelete) {

                                var deletedItems:Array = [];

                                var item:TransformItem;

                                var multiple:Boolean = Boolean(_selectedItems.length > 1);

                                var i:int = _selectedItems.length;

                                while (i--) {

                                        item = _selectedItems[i];

                                        if (item.onPressDelete($e, multiple)) {

                                                deletedItems[deletedItems.length] = item;

                                        }

                                }

                                if (deletedItems.length > 0) {

                                        dispatchEvent(new TransformEvent(TransformEvent.DELETE, deletedItems));

                                }

                        }

                }



                /**

                 * Deletes all selected items.

                 *

                 * @param $e Accepts an optional Event in case you want to use this as an event handler

                 */

                public function deleteSelection($e:Event = null):void {

                        var deletedItems:Array = [];

                        var item:TransformItem;

                        for (var i:int = _selectedItems.length - 1; i > -1; i--) {

                                item = _selectedItems[i];

                                item.deleteObject();

                                deletedItems.push(item);

                        }

                        if (deletedItems.length != 0) {

                                dispatchEvent(new TransformEvent(TransformEvent.DELETE, deletedItems));

                        }

                }



                /** @private **/

                private function onPressArrowKey($e:KeyboardEvent = null):void {

                        if (_arrowKeysMove && _enabled && _selectedItems.length != 0 && !(_stage.focus is TextField)){

                                var moveAmount:int = 1;

                                // Move faster if the shift key is down.

                                if(isKeyDown(Keyboard.SHIFT)){

                                        moveAmount = 10;

                                }

                                switch($e.keyCode) {

                                        case Keyboard.UP:

                                                moveSelection(0, -moveAmount);

                                                dispatchEvent(new TransformEvent(TransformEvent.FINISH_INTERACTIVE_MOVE, _selectedItems.slice()));

                                                break;

                                        case Keyboard.DOWN:

                                                moveSelection(0, moveAmount);

                                                dispatchEvent(new TransformEvent(TransformEvent.FINISH_INTERACTIVE_MOVE, _selectedItems.slice()));

                                                break;

                                        case Keyboard.LEFT:

                                                moveSelection(-moveAmount, 0);

                                                dispatchEvent(new TransformEvent(TransformEvent.FINISH_INTERACTIVE_MOVE, _selectedItems.slice()));

                                                break;

                                        case Keyboard.RIGHT:

                                                moveSelection(moveAmount, 0);

                                                dispatchEvent(new TransformEvent(TransformEvent.FINISH_INTERACTIVE_MOVE, _selectedItems.slice()));

                                                break;

                                }

                        }

                }



                /** @private **/

                public function centerOrigin():void {

                        setOrigin(getSelectionCenter());

                }



                /**

                 * Gets the center point of the current selection

                 *

                 * @return Center Point of the current selection

                 */

                public function getSelectionCenter():Point {

                        var bounds:Rectangle = _dummyBox.getBounds(_dummyBox);

                        return _parent.globalToLocal(_dummyBox.localToGlobal(new Point(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2)));

                }



                /**

                 * Gets the bounding Rectangle of the current selection (not including handles)

                 *

                 * @param targetCoordinateSpace The display object that defines the coordinate system to use.

                 * @return Bounding Rectangle of the current selection (not including handles).

                 */

                public function getSelectionBounds(targetCoordinateSpace:DisplayObject=null):Rectangle {

                        if (_parent.contains(_dummyBox) && _selectedItems.length != 0) {

                                if (targetCoordinateSpace) {

                                        return _dummyBox.get…

Large files files are truncated, but you can click here to view the full file