         if (_includeInLayout == value)
             return;
 
-		var oldValue:Boolean = _includeInLayout;
+        var oldValue:Boolean = _includeInLayout;
         _includeInLayout = value;
-		dispatchPropertyChangeEvent("includeInLayout", oldValue, value);
+        dispatchPropertyChangeEvent("includeInLayout", oldValue, value);
             
         invalidateParentSizeAndDisplayList();
         // TODO EGeorgie: if the displayObject is shared, we need to
         // invalidateDisplayList();
     }
 
-	//----------------------------------
-	//  maxSize
-	//----------------------------------
+    //----------------------------------
+    //  maxSize
+    //----------------------------------
 
     /**
      *  The TBounds of the maximum item size.
-     *  <code>preferredSize</code> <= <code>maxSize</code> must be true.
+     *  <code>preferredSize</code> &lt;= <code>maxSize</code> must be true.
      */
     public function get maxSize():Point
     {

        _measuredX = value;
    }

	//----------------------------------
	//  measuredY
	//----------------------------------
    
	/**
     *  @private
     *  Storage for the measuredY property.
     */
    private var _measuredY:Number = 0;
    
 	/**
     *  Documentation is not currently available.
     */
    public function get measuredY():Number

     */
    public function getBitmapData(transparent:Boolean = true, fillColor:uint = 0xFFFFFFFF):BitmapData
    {
        // NOTE: This code will not work correctly when we share
        // display objects across multiple graphic elements.
        var bitmapData:BitmapData = new BitmapData(actualSize.x, actualSize.y, transparent, fillColor);
        var oldPos:Point = actualPosition;
        
        setActualPosition(0, 0);
        bitmapData.draw(displayObject, displayObject.transform.matrix);
        setActualPosition(oldPos.x, oldPos.y);
    
        return bitmapData;
    }

    /**
     *  Documentation is not currently available.
     */
    public function applyMask():void
    {
        if (displayObject && _mask)
        {
            displayObject.mask = _mask;
            if (!isMaskInElementSpace)
            {
                var maskMatrix:Matrix = _mask.transform.matrix;
                maskMatrix.concat(displayObject.transform.matrix);
                _mask.transform.matrix = maskMatrix;
                isMaskInElementSpace = true;
            }
        }
    }

    /**
     *  Documentation is not currently available.
     */
    protected function applyMaskType():void
    {
        if (_mask)
        {
            if (_maskType == MaskType.CLIP)
            {
                // Turn off caching on mask
                _mask.cacheAsBitmap = false;
                // Save the original filters and clear the filters property
                //originalMaskFilters = _mask.filters;
                _mask.filters = [];
            }
            else if (_maskType == MaskType.ALPHA)
            {
                _mask.cacheAsBitmap = true;
                //notifyElementLayerChanged(); // Trigger recreation of the layers
                displayObject.cacheAsBitmap = true;
            }
        }
    }

    /**
     *  Documentation is not currently available.
     */
    protected function clearTransformProperties():void
    {
        scaleXChanged = false;
        scaleYChanged = false;
        xChanged = false;
        yChanged = false;
        rotationChanged = false;
    }

    /**
     *  Dispatches a propertyChange event.
     */
    protected function dispatchPropertyChangeEvent(prop:String, oldValue:*,
                                                   value:*):void
    {
        dispatchEvent(PropertyChangeEvent.createUpdateEvent(
                           this, prop, oldValue, value));

    }

    // TODO EGeorgie: can we use the standart IInvalidating methods instead of
    // notifyElementLayerChanged()?
    
    /**
     *  Utility method that notifies our host that we have changed and need
     *  our layer to be updated.
     */
    protected function notifyElementLayerChanged():void
    {
        // TODO EGeorgie: figure this out. For now, invalidateDisplayList
        // to preseve original behavior before layout API unification.
        invalidateDisplayList();
        
        if (elementHost)
            elementHost.elementLayerChanged(this);
    }

    /**
     *  Calling this method results in a call to the elements's
     *  <code>validateProperties()</code> method
     *  before the display list is rendered.
     *
     *  <p>Subclasses should do their work in 
     *  <code>commitProperties()</code>.</p>
     */
    public function invalidateProperties():void
    {
        if (invalidatePropertiesFlag)
            return;
        invalidatePropertiesFlag = true;

        // TODO EGeorgie: hook up directly with the layout manager?
        if (elementHost && elementHost is IInvalidating)
            IInvalidating(elementHost).invalidateProperties();
    }

    /**
     *  Calling this method results in a call to the elements's
     *  <code>validateSize()</code> method
     *  before the display list is rendered.
     *
     *  <p>Subclasses should override and do their measurement in
     *  <code>measure()</code>.
     *  By default when <code>explicitWidth</code> and <code>explicitHeight</code>
     *  are set, <code>measure()</code> will not be called. To override this
     *  default behavior subclasses should override <code>skipMeasure()</code>.</p>
     */
    public function invalidateSize():void
    {
        if (invalidateSizeFlag)
            return;
        invalidateSizeFlag = true;

        // TODO EGeorgie: hook up directly with the layout manager?
        if (elementHost)
            elementHost.elementSizeChanged(this);
    }

    /**
     *  Helper method to invalidate parent size and display list if
     *  this object affects its layout (includeInLayout is true).
     */
    protected function invalidateParentSizeAndDisplayList():void
    {
        if (!includeInLayout)
            return;

        // We want to invalidate both the parent size and parent display list.
        if (elementHost && elementHost is IInvalidating)
        {
            IInvalidating(elementHost).invalidateSize();
            IInvalidating(elementHost).invalidateDisplayList();
        }
    }

    /**
     *  Calling this method results in a call to the elements's
     *  <code>validateDisplayList()</code> method
     *  before the display list is rendered.
     *
     *  <p>Subclasses should override and do their work in
     *  <code>updateDisplayList()</code>.</p>
     */
    public function invalidateDisplayList():void
    {
        if (invalidateDisplayListFlag)
            return;
        invalidateDisplayListFlag = true;

        // TODO EGeorgie: make sure elements that share the display object
        // will be invalidated as well.
