     	{
     		_truncation = value;
     		
+            mx_internal::invalidateCompose = true;
+                 		
     		invalidateSize();
     		invalidateDisplayList();
     	}

     */
    protected function composeOnHeightChange():Boolean
    {
        return false;
    }


		for (var i:int = 0; i < n; i++)
		{
			var textLine:TextLine = TextLine(mx_internal::textLines[i]);
            if (container is IVisualElementContainer)
                IVisualElementContainer(container).mx_internal::$removeChild(textLine);
            else
                container.removeChild(textLine);

            // Reset x and y to be relative to 0,0.
            textLine.x -= _lastDrawX;
            textLine.y -= _lastDrawY;
		}
		
		_lastDrawX = 0;
		_lastDrawY = 0;
	}

    /**
     *  @private
     *  If the text lines are in a shared container then x and y have to be
     *  adjusted if offsets.x, offsets.y, layoutX or layoutY changes.  When
     *  these are changed, our updateDisplayList() is called but if we don't
     *  recompose we may need to adjust the position of the text lines.
     */
    mx_internal function adjustTextLines():void
    {
        var n:int = mx_internal::textLines.length;
        if (n == 0)
            return;

        // Are there any adjustments to be made?
        if (_lastDrawX == drawX && _lastDrawY == drawY)
            return;
            
        for (var i:int = 0; i < n; i++)
        {
            var textLine:TextLine = TextLine(mx_internal::textLines[i]);
            
            textLine.x +=  drawX - _lastDrawX;
            textLine.y += drawY - _lastDrawY;
        }

        _lastDrawX = drawX;
        _lastDrawY = drawY;
    }
    
    /**
     *  @private
     *  Does the bounds of the contents rectangle fit within the bounds
     *  of the composition rectangle?
     */
    mx_internal function isTextOverset(composeWidth:Number, 
                                       composeHeight:Number):Boolean
    {        
        // The composition bounds available for text placement.
        var compositionRect:Rectangle = new Rectangle(0, 0, 
                                                      composeWidth,
                                                      composeHeight);
    
        // Add in a half-pixel slop factor to the throw-away rectangle (do
        // not modify mx_internal::bounds).  This covers the case where the
        // y (textLine.y - textLine.ascent) is slightly less than 0 because of
        // rounding errors.
        compositionRect.inflate(0.25, 0.25);

        // The bounds of the composed text.
        var contentRect:Rectangle = mx_internal::bounds;
       
        // Does the text fit totally within the composition area?  This is
        // a Rectangle.contains but allows for composition width and/or height
        // to be NaN.
        var isOverset:Boolean = (contentRect.top < compositionRect.top || 
                                 contentRect.left < compositionRect.left ||
                                 (!isNaN(compositionRect.bottom) &&
                                 contentRect.bottom > compositionRect.bottom) ||
                                 (!isNaN(compositionRect.right) &&
                                 contentRect.right > compositionRect.right));
                   
        //trace(id, drawnDisplayObject.name, "bounds", contentRect, "overset", isOverset);
        
        return isOverset;                                                     
    } 
    
     /**
	 *  Use scrollRect to clip overset lines.
	 *  But don't read or write scrollRect if you can avoid it,
	 *  because this causes Player 10.0 to allocate memory.
