transformTool.addEventListener(TransformTool.CONTROL_MOVE, onMoveEvent);

function onMoveEvent(event){

   if (transformTool.target.x>maxXPos) transformTool.target.x = maxXPos;

}

        var currentPoint:Point=defaultTool.target.localToGlobal(zeroPoint);

 

        trace(defaultTool.target.x, currentPoint); // 490 (x=506, y=558)

 

        if (defaultTool.target.x > x2) {

                trace("1.",defaultTool.target.x); // 1. 490

                defaultTool.target.x=x2;

                trace("2.",defaultTool.target.x); // 2. 454

        }

var tMatrix:Matrix = defaultTool.toolMatrix;

        if (defaultTool.target.x>x2) {

                tMatrix.tx = x2;

                defaultTool.toolMatrix = tMatrix;

        }

import com.senocular.display.*;

 

var transformTool = new TransformTool();

addChild(transformTool);

transformTool.target = mc;

var maxXPos = 200;

transformTool.addEventListener(TransformTool.TRANSFORM_TARGET, onMoveEvent);

function onMoveEvent(event){

        if (event.target.target.x>maxXPos) {          

           event.target.target.x = maxXPos;

           event.target.target = null;

           event.target.target = mc;

   }

}

                private var _maxX1:Number = 0;

                private var _maxY1:Number = 0;

                private var _maxX2:Number = Infinity;

                private var _maxY2:Number = Infinity;

 

//..........

 

                public function get maxX1():Number { return _maxX1;        }

                public function set maxX1(n:Number):void {         _maxX1 = n;        }

                public function get maxY1():Number { return _maxY1;        }

                public function set maxY1(n:Number):void {         _maxY1 = n;        }

                public function get maxY2():Number { return _maxY2;        }

                public function set maxY2(n:Number):void {         _maxY2 = n;        }

                public function get maxX2():Number { return _maxX2;        }

                public function set maxX2(n:Number):void {         _maxX2 = n;        }

 

//.....................

 

                private function enforceLimits():void {

 

                        var currScale:Number;

                        var angle:Number;

                        var enforced:Boolean = false;

 

                        // use global matrix

                        var _globalMatrix:Matrix = _toolMatrix.clone();

                        _globalMatrix.concat(transform.concatenatedMatrix);

 

                        // check current scale in X

                        currScale = Math.sqrt(_globalMatrix.a * _globalMatrix.a + _globalMatrix.b * _globalMatrix.b);

                        if (currScale > _maxScaleX) {

                                // set scaleX to no greater than _maxScaleX

                                angle = Math.atan2(_globalMatrix.b, _globalMatrix.a);

                                _globalMatrix.a = Math.cos(angle) * _maxScaleX;

                                _globalMatrix.b = Math.sin(angle) * _maxScaleX;

                                enforced = true;

                        }

 

                        // check current scale in Y

                        currScale = Math.sqrt(_globalMatrix.c * _globalMatrix.c + _globalMatrix.d * _globalMatrix.d);

                        if (currScale > _maxScaleY) {

                                // set scaleY to no greater than _maxScaleY

                                angle= Math.atan2(_globalMatrix.c, _globalMatrix.d);

                                _globalMatrix.d = Math.cos(angle) * _maxScaleY;

                                _globalMatrix.c = Math.sin(angle) * _maxScaleY;

                                enforced = true;

                        }

 

 

                        if (_globalMatrix.tx < _maxX1) {

                                _globalMatrix.tx = _maxX1;

                                enforced = true;

                        }

 

                        if (_globalMatrix.tx > _maxX2) {

                                _globalMatrix.tx = _maxX2;

                                enforced = true;

                        }

 

                        if (_globalMatrix.ty < _maxY1) {

                                _globalMatrix.ty = _maxY1;

                                enforced = true;

                        }

 

                        if (_globalMatrix.ty > _maxY2) {

                                _globalMatrix.ty = _maxY2;

                                enforced = true;

                        }

 

 

 

                        // if scale was enforced, apply to _toolMatrix

                        if (enforced) {

                                _toolMatrix = _globalMatrix;

                                var current:Matrix = transform.concatenatedMatrix;

                                current.invert();

                                _toolMatrix.concat(current);

                        }

                }