         setIsTruncated(true);
     }
         
+    /**
+     *  @private
+     *  width and height are the ones used to do the compose, not the measured
+     *  results resulting from the compose.
+     */
+    private function truncateExplicitLineBreakText(width:Number, height:Number):void
+	{
+        // 1. Measure the space that the truncation indicator will take
+        // by composing the truncation resource using the same bounds
+        // and formats.  The measured indicator lines could be cached but
+        // as well as being dependent on the indicator string, they are 
+        // dependent on the given width.            
+        staticTextElement.text = truncationIndicatorResource;
+        var indicatorLines:Vector.<DisplayObject> =
+            new Vector.<DisplayObject>();
+        var indicatorBounds:Rectangle = new Rectangle(0, 0, width, NaN);
+
+        createTextLinesFromTextBlock(staticTextBlock, 
+                                     indicatorLines, 
+                                     indicatorBounds);
+                                           
+        releaseLinesFromTextBlock();
+
+        // check each line to see if it needs truncation
+        var n:int = textLines.length;
+        for (var i:int = 0; i < n; i++)
+        {
+            var line:TextLine = textLines[i] as TextLine;
+            // if the line is wider than bounds or off the left side
+            // TODO (aharui): What if text runs off left side because of
+            // alignment or direction?
+            if ((line.x + line.width) > width)
+            {
+                // clip this line
+                var lineLength:int = line.rawTextLength;
+                // start chopping from the end until it fits
+                while (--lineLength > 0)
+                {
+                    var lineStr:String = text.substr(line.textBlockBeginIndex, lineLength);
+                    lineStr += truncationIndicatorResource;
+                    staticTextElement.text = lineStr;
+                    var clippedLines:Vector.<DisplayObject> =
+            	        new Vector.<DisplayObject>();
+
+                    createTextLinesFromTextBlock(staticTextBlock, 
+                                                 clippedLines, 
+                                                 indicatorBounds);
+                                           
+                    releaseLinesFromTextBlock();
+                    if (clippedLines.length == 1 && 
+                        (clippedLines[0].x + clippedLines[0].width) <= width)
+                    {
+                        // replace with the clipped line
+                        clippedLines[0].x = line.x;
+                        clippedLines[0].y = line.y;
+                        textLines[i] = clippedLines[0];
+                        break;
+                    }
+                    
+                }
+            }
+        }
+    }
+
     /** 
 	 *  @private
      *  Calculates the last line that fits in the given height and line count 

            }
            
            if (truncateAtCharPosition < line.textBlockBeginIndex)
                truncationLineIndex--;
            else
                truncationLineIndex++;
                
            line = TextLine(textLines[truncationLineIndex]);
        }

     *  Adapted from justification code in TLF's
     *  TextLineFactory.textLinesFromString().
     */
    private function truncateText(width:Number, height:Number, lineBreak:String):void
	{
	    var lineCountLimit:int = maxDisplayedLines;
        var somethingFit:Boolean = false;
        var truncLineIndex:int = 0;    

        if (lineBreak == "explicit")
        {
            truncateExplicitLineBreakText(width, height);
            return;
        }

        // Compute the truncation line.
        truncLineIndex = computeLastAllowedLineIndex(height, lineCountLimit);
        // add extra line in case we wordwrapped some characters
        // onto extra lines, but don't go off the end
        truncLineIndex = Math.min(truncLineIndex + 1, textLines.length - 1);
                                     
        if (truncLineIndex >= 0)
        {
