                                            position:Vector3D, 
                                            postLayoutPosition:Vector3D):void
     {
-        TransformUtil.transformPointToParent(this,
-                                             localPosition,
-                                             position,
-                                             postLayoutPosition,
-                                             _layoutFeatures);
+        if (_layoutFeatures != null)
+        {
+            _layoutFeatures.transformPointToParent(true, localPosition,
+                position, postLayoutPosition);
+        }
+        else
+        {
+            if (xformPt == null)
+                xformPt = new Point();
+            if (localPosition)
+            {
+                xformPt.x = localPosition.x;
+                xformPt.y = localPosition.y;
+            }
+            var tmp:Point = transform.matrix.transformPoint(xformPt);
+            if (position != null)
+            {            
+                position.x = tmp.x;
+                position.y = tmp.y;
+                position.z = 0;
+            }
+            if (postLayoutPosition != null)
+            {
+                postLayoutPosition.x = tmp.x;
+                postLayoutPosition.y = tmp.y;
+                postLayoutPosition.z = 0;
+            }
+        }
     }
 
     /**

        _layoutFeatures = features;

        invalidateTransform();
        return features;
    }
    
    private function invalidateTransform():void

            _includeInLayout = false;
        }
        
        if (_layoutFeatures == null)
        {
            // TODO (chaase): should provide a way to return to having no
            // layoutFeatures if we call this later with a more trivial
            // situation
            var needAdvancedLayout:Boolean = 
                (scale != null && ((!isNaN(scale.x) && scale.x != 1) || 
                    (!isNaN(scale.y) && scale.y != 1) ||
                    (!isNaN(scale.z) && scale.z != 1))) || 
                (rotation != null && ((!isNaN(rotation.x) && rotation.x != 0) || 
                    (!isNaN(rotation.y) && rotation.y != 0) ||
                    (!isNaN(rotation.z) && rotation.z != 0))) || 
                (translation != null && translation.z != 0 && !isNaN(translation.z)) ||
                postLayoutScale != null ||
                postLayoutRotation != null ||
                postLayoutTranslation != null;
            if (needAdvancedLayout)
                initAdvancedLayoutFeatures();
        }
        if (_layoutFeatures != null)
        {
            _layoutFeatures.transformAround(transformCenter, scale, rotation,
                translation, postLayoutScale, postLayoutRotation,
                postLayoutTranslation);
            invalidateTransform();      

            // Will not invalidate parent if we have set _includeInLayout to false
            // in the beginning of the method
            invalidateParentSizeAndDisplayList();
        }
        else
        {
            if (rotation != null && !isNaN(rotation.z))
                this.rotation = rotation.z;
            if (scale != null)
            {
                scaleX = scale.x;
                scaleY = scale.y;
            }            
            if (transformCenter == null)
            {
                if (translation != null)
                {
                    x = translation.x;
                    y = translation.y;
                }
            }
            else
            {
                if (xformPt == null)
                    xformPt = new Point();
                xformPt.x = transformCenter.x;
                xformPt.y = transformCenter.y;                
                var postXFormPoint:Point = 
                    transform.matrix.transformPoint(xformPt);
                if (translation != null)
                {
                    x += translation.x - postXFormPoint.x;
                    y += translation.y - postXFormPoint.y;
                }
                else
                {
                    var xformedPt:Point = 
                        transform.matrix.transformPoint(xformPt);
                    x += xformedPt.x - postXFormPoint.x;
                    y += xformedPt.y - postXFormPoint.y;                                   
                }
            }
        }

        if (!invalidateLayout)
            _includeInLayout = oldIncludeInLayout;
    }
    
    /**
     * A utility method to transform a point specified in the local
     * coordinates of this object to its location in the object's parent's 
     * coordinates. The pre-layout and post-layout result will be set on 
     * the <code>position</code> and <code>postLayoutPosition</code>
     * parameters, if they are non-null.
     * 
     * @param localPosition The point to be transformed, specified in the
     * local coordinates of the object.
     * @position A Vector3D point that will hold the pre-layout
     * result. If null, the parameter is ignored.
     * @postLayoutPosition A Vector3D point that will hold the post-layout
     * result. If null, the parameter is ignored.
     * 
     *  @langversion 3.0
     *  @playerversion Flash 10
