      *  @playerversion AIR 1.1
      *  @productversion Flex 3
      */
-	public function set layoutScaleX(value:Number):void
-	{
-		layout.scaleX = value;
-		invalidate();
-	}
-	
-    /**
-     * @private
-     */
-	public function get layoutScaleX():Number
-	{
-		return layout.scaleX;
-	}
-	
+    public function set layoutScaleX(value:Number):void
+    {
+        layout.scaleX = value;
+        invalidate();
+    }
+    
+    /**
+     * @private
+     */
+    public function get layoutScaleX():Number
+    {
+        return layout.scaleX;
+    }
+    
     /**
      * layout transform convenience property.  Represents the scale along the Y axis of the layout matrix used in layout and in 
      * the computed transform.

        var targetPosition:Vector3D = (transformCenterPosition == null)? staticTranslation:transformCenterPosition;
        var postLayoutTargetPosition:Vector3D = (postLayoutTransformCenterPosition == null)? staticOffsetTranslation:postLayoutTransformCenterPosition;

		// now update our transform values.		
        if (rotation != null)
        {
            if (!isNaN(rotation.x))

            y += postLayoutTransformOffsets.y;
            z += postLayoutTransformOffsets.z;
        }
            
        build3DMatrix(m, tx, ty, tz, sx, sy, sz, rx, ry, rz, x, y, z);
        // Always prepend last
        if (stretchX != 1 || stretchY != 1)
            m.prependScale(stretchX, stretchY, 1);  

        _flags |= COMPUTED_MATRIX3D_VALID;
        return m;           
    }
    
    
    /**
     * @private
     * convenience function for building a 2D matrix from the convenience properties 
     */
    public static function build2DMatrix(m:Matrix,
                                    tx:Number,ty:Number,
                                    sx:Number,sy:Number,
                                    rz:Number,
                                    x:Number,y:Number):void
    {
        m.translate(-tx,-ty);
        m.scale(sx,sy);
        m.rotate(rz* RADIANS_PER_DEGREES);
        m.translate(x+tx,y+ty);         
    }


    /**
     * @private
     * convenience function for building a 3D matrix from the convenience properties 
     */
    public static function build3DMatrix(m:Matrix3D,
                                        tx:Number,ty:Number,tz:Number,
                                        sx:Number,sy:Number,sz:Number,
                                        rx:Number,ry:Number,rz:Number,
                                        x:Number,y:Number,z:Number):void
    {
        reVR.x = rx * RADIANS_PER_DEGREES;
        reVR.y = ry * RADIANS_PER_DEGREES;
        reVR.z = rz * RADIANS_PER_DEGREES;
        m.recompose(reV);
        if(sx == 0)
            sx = ZERO_REPLACEMENT_IN_3D;
        if(sy == 0)
            sy = ZERO_REPLACEMENT_IN_3D;
        if(sz == 0)
            sz = ZERO_REPLACEMENT_IN_3D;
        m.prependScale(sx,sy,sz);
        m.prependTranslation(-tx,-ty,-tz);
        m.appendTranslation(tx+x,ty+y,tz+z);
    }                                   
                        

    /**
     * A utility method to update the rotation and scale of the transform 
     * while keeping a particular point, specified in the component's 
     * own coordinate space, fixed in the parent's coordinate space.  
     * This function will assign the rotation and scale values provided, 
     * then update the x/y/z properties as necessary to keep tx/ty/tz fixed.
     * @param rx,ry,rz the new values for the rotation of the transform
     * @param sx,sy,sz the new values for the scale of the transform
     * @param tx,ty,tz the point, in the component's own coordinates, 
     * to keep fixed relative to its parent.
     */
    public function transformPointToParent(propertyIs3D:Boolean,
        transformCenter:Vector3D, currentPosition:Vector3D,
        currentPostLayoutPosition:Vector3D):void
