org.eclipse.gmf.runtime.draw2d.ui/src/org/eclipse/gmf/runtime/draw2d/ui/figures/WrapLabel.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2002, 2009 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    IBM Corporation - initial API and implementation
  *    Mariot Chauvin <mariot.chauvin@obeo.fr> - bug 272658
  ****************************************************************************/

 package org.eclipse.gmf.runtime.draw2d.ui.figures;

 import org.eclipse.draw2d.FigureUtilities;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode;
 import org.eclipse.swt.graphics.Font;
 import org.eclipse.swt.graphics.FontMetrics;
 import org.eclipse.swt.graphics.Image;

 import com.ibm.icu.text.BreakIterator;
 import com.ibm.icu.util.StringTokenizer;

 /**
  * An extended label that has the following extra features:
  *
  * 1- It is capable of showing selection and focus feedback (primary or
  * secondary) 2- It is capable of optionally underlining the label's text 3- It
  * is capable of wrapping the label's text at a given width with a given
  * alignment 4- It is capable of supporting multiple label icons (temporary
  * feature)
  *
  * This class was originally deriving off Draw2d's <code>Label</code> class
  * but with the introduction of the auto-wrapping feature, a copy had to be made
  * overriding was not straightforward. Hopefully, this extended version can be
  * pushed to opensource
  *
  * <p>
  * Code taken from Eclipse reference bugzilla #98820
  *
  * @author melaasar, crevells
  * @deprecated This class has been deprecated and may be removed in the future.
  *             Use <code>WrappingLabel</code> instead. This class now extends
  *             from <code>WrappingLabel</code> so the behavior should be the
  *             same. If client code is calling one of the methods on
  *             <code>WrapLabel</code> that no longer exists, evaluate whether
  *             this is necessary or not.
  */
 public class WrapLabel
     extends WrappingLabel {

     /** the label's text used in painting after applying required styles */
     private String subStringText;

     /**
      * Construct an empty Label.
      *
      * @since 2.0
      */
     public WrapLabel() {
         super();
     }

     /**
      * Construct a Label with passed String as its text.
      *
      * @param s
      *            the label text
      * @since 2.0
      */
     public WrapLabel(String s) {
         super(s);

         // Compensate for the fact that the original wraplabel never called the
         // default constructor to set the default layout values.
         setTextWrapAlignment(CENTER);
     }

     /**
      * Construct a Label with passed Image as its icon.
      *
      * @param i
      *            the label image
      * @since 2.0
      */
     public WrapLabel(Image i) {
         super(i);

         // Compensate for the fact that the original wraplabel never called the
         // default constructor to set the default layout values.
         setTextWrapAlignment(CENTER);
     }

     /**
      * Construct a Label with passed String as text and passed Image as its
      * icon.
      *
      * @param s
      *            the label text
      * @param i
      *            the label image
      * @since 2.0
      */
     public WrapLabel(String s, Image i) {
         super(s, i);

         // Compensate for the fact that the original wraplabel never called the
         // default constructor to set the default layout values.
         setTextWrapAlignment(CENTER);
     }

     /**
      * Calculates the size of the Label's text size. The text size calculated
      * takes into consideration if the Label's text is currently truncated. If
      * text size without considering current truncation is desired, use
      * {@link #calculateTextSize(int, int)}.
      *
      * @return the size of the label's text, taking into account truncation
      * @since 2.0
      * @deprecated If this behavior is required then a request can be made (with
      *             justification) for the WrappingLabel.
      */
     protected Dimension calculateSubStringTextSize() {
         Font f = getFont();
 		return getTextExtents(getSubStringText(), f, getFigureMapMode().DPtoLP(FigureUtilities.getFontMetrics(f).getHeight()));
     }

     /**
      * Calculates and returns the size of the Label's text. Note that this
      * Dimension is calculated using the Label's full text, regardless of
      * whether or not its text is currently truncated. If text size considering
      * current truncation is desired, use {@link #calculateSubStringTextSize()}.
      *
 	 * @param wHint a width hint
 	 * @param hHint a height hint
      * @return the size of the label's text, ignoring truncation
      * @since 2.0
      * @deprecated If this behavior is required then a request can be made (with
      *             justification) for the WrappingLabel.
      */
     protected Dimension calculateTextSize(int wHint, int hHint) {
         return getTextFlow().getPreferredSize(wHint, hHint);
     }

     /**
      * Returns the bounds of the Label's icon.
      *
      * @return the icon's bounds
      * @since 2.0
      * @deprecated The icon location can be retrieved with
      *             {@link #getIconLocation()} and the icon(s) size can be
      *             retrieved with {@link #getTotalIconSize()}.
      */
     public Rectangle getIconBounds() {
         if (hasIcons()) {
         	final Point safeIconLocation = getIconLocation() != null ? getIconLocation() : new Point(0,0);
             return new Rectangle(getBounds().getLocation().translate(
                 safeIconLocation), getTotalIconSize());
         }
         return new Rectangle(0, 0, 0, 0);
     }

     /**
      * Calculates the amount of the Label's current text will fit in the Label,
      * including an elipsis "..." if truncation is required.
      *
      * @return the substring
      * @since 2.0
      * @deprecated If this behavior is required then a request can be made (with
      *             justification) for the WrappingLabel.
      */
     public String getSubStringText() {
         if (subStringText != null)
             return subStringText;

         String theText = getText();
         int textLen = theText.length();
         if (textLen == 0) {
             return subStringText = "";//$NON-NLS-1$;;
         }
         Dimension size = getSize();
         Dimension shrink = getPreferredSize(size.width, size.height)
             .getDifference(size);
         Dimension effectiveSize = getTextSize().getExpanded(-shrink.width,
             -shrink.height);

         if (effectiveSize.height == 0) {
             return subStringText = "";//$NON-NLS-1$;
         }

         Font f = getFont();
         FontMetrics metrics = FigureUtilities.getFontMetrics(f);
         IMapMode mm = getFigureMapMode();
         int fontHeight = mm.DPtoLP(metrics.getHeight());
         int charAverageWidth = mm.DPtoLP(metrics.getAverageCharWidth());
         int maxLines = (int) (effectiveSize.height / (double) fontHeight);
         if (maxLines == 0) {
             return subStringText = "";//$NON-NLS-1$
         }

         StringBuffer accumlatedText = new StringBuffer();
         StringBuffer remainingText = new StringBuffer(theText);

         int effectiveSizeWidth = effectiveSize.width;
         int widthHint = Math.max(effectiveSizeWidth
             - getTruncationStringSize().width, 0);
         int i = 0, j = 0;
         while (remainingText.length() > 0 && j++ < maxLines) {
             i = getLineWrapPosition(remainingText.toString(), f,
                 effectiveSizeWidth, fontHeight);

             if (accumlatedText.length() > 0)
                 accumlatedText.append('\n');

             if (i == 0 || (remainingText.length() > i && j == maxLines)) {
                 i = getLargestSubstringConfinedTo(remainingText.toString(), f,
                     widthHint, fontHeight, charAverageWidth);
                 accumlatedText.append(remainingText.substring(0, i));
                 accumlatedText.append(getEllipse());
             } else
                 accumlatedText.append(remainingText.substring(0, i));
             remainingText.delete(0, i);
         }
         return subStringText = accumlatedText.toString();
     }

     /**
      * Returns the size of the Label's current text. If the text is currently
      * truncated, the truncated text with its ellipsis is used to calculate the
      * size.
      *
      * @return the size of this label's text, taking into account truncation
      * @since 2.0
      * @deprecated If this behavior is required then a request can be made (with
      *             justification) for the WrappingLabel.
      */
     protected Dimension getSubStringTextSize() {
         return calculateSubStringTextSize();
     }

     /**
      * Returns the location of the label's text relative to the label.
      *
      * @return the text location
      * @since 2.0
      * @deprecated Use <code>getTextBounds().getLocation()</code> instead.
      */
     protected Point getTextLocation() {
         return getTextBounds().getLocation();
     }

     /**
      * Returns the size of the label's complete text. Note that the text used to
      * make this calculation is the label's full text, regardless of whether the
      * label's text is currently being truncated and is displaying an ellipsis.
      * If the size considering current truncation is desired, call
      * {@link #getSubStringTextSize()}.
      *
      * @param wHint
      *            a width hint
      * @param hHint
      *            a height hint
      * @return the size of this label's complete text
      * @since 2.0
      * @deprecated If this behavior is required then a request can be made (with
      *             justification) for the WrappingLabel.
      */
     protected Dimension getTextSize(int wHint, int hHint) {
         return getTextFlow().getPreferredSize(wHint, hHint);
     }

     /**
      * Gets the text size given the current size as a width hint
      */
     private final Dimension getTextSize() {
         Rectangle r = getBounds();
         return getTextSize(r.width, r.height);
     }

     /**
      * @see IFigure#invalidate()
      */
     public void invalidate() {
         subStringText = null;
         super.invalidate();
     }

     /**
      * Returns <code>true</code> if the label's text is currently truncated
      * and is displaying an ellipsis, <code>false</code> otherwise.
      *
      * @return <code>true</code> if the label's text is truncated
      * @since 2.0
      * @deprecated If this behavior is required then a request can be made (with
      *             justification) for the WrappingLabel.
      */
     public boolean isTextTruncated() {
         return !getSubStringTextSize().equals(getTextSize());
     }

     /**
      * Return the ellipse string.
      *
      * @return the <code>String</code> that represents the fact that the text
      *         has been truncated and that more text is available but hidden.
      *         Usually this is represented by "...".
      *         @deprecated Renamed to {@link #getTruncationString()}
      */
     protected String getEllipse() {
         return ELLIPSIS;
     }

     protected String getTruncationString() {
         if (getEllipse() != null) {
             return getEllipse();
         }
         return ELLIPSIS;
     }

     /**
      * @return whether the label text wrap is on
      * @deprecated Use {@link #isTextWrapOn()} instead. This method was renamed
      *             because it never indicated if the text was actually wrapped,
      *             but whether text wrapping was turned on in the label.
      */
     public boolean isTextWrapped() {
         return isTextWrapOn();
     }

     /**
      * Sets the wrapping width of the label text. This is only valid if text
      * wrapping is turned on
      *
      * @param i
      *            The label text wrapping width
      * @deprecated this method was empty and never called
      */
     public void setTextWrapWidth(int i) {
         // do nothing
     }

     /**
      * Sets the wrapping width of the label text. This is only valid if text
      * wrapping is turned on
      *
      * @param i
      *            The label text wrapping width
      * @deprecated Call {@link #setTextJustification(int)} and
      *             {@link #setAlignment(int)} instead. This method was somewhat
      *             controlling text justification and label alignment, but they
      *             are really two independent settings. Previously,
      *             setTextWrapAlignment(CENTER) would not only center-justifies
      *             the text, but also put the label in the center. Now, you need
      *             to call {@link #setTextJustification(int)} to justify the
      *             text (this only affects text when it is wrapped) and
      *             {@link #setAlignment(int)} to position the text correctly in
      *             the label. If you want the text in the center of the label
      *             than call <code>setAlignment(PositionConstants.CENTER)</code>.
      *             Look at the implementation of this method to see how your
      *             code needs to be migrated.
      */
     public void setTextWrapAlignment(int i) {
         setTextJustification(i);

         // The old WrapLabel's Text Wrap Alignment (i.e. justification) and
         // Label Alignment did not work properly. They worked together
         // previously so we need to compensate for this here.
         switch (i) {
             case LEFT:
                  setAlignment(TOP | LEFT);
                 break;
             case CENTER:
                 setAlignment(TOP);
                 break;
             case RIGHT:
                 setAlignment(TOP | RIGHT);
                 break;
             default:
                 break;
         }
     }

     /**
      * @deprecated This never worked properly anyways. Call
      *             {@link #setAlignment(int)} instead to position the icon and
      *             text within the label.
      */
     public void setLabelAlignment(int alignment) {
         // setLabelAlignment() never worked properly instead the label alignment
         // seemed to be based on the text justification. Therefore, if it was
         // set it will be ignored.
     }

     /**
      * @return the label text wrapping width
      * @deprecated Renamed to {@link #getTextJustification()}
      */
     public int getTextWrapAlignment() {
         return getTextJustification();
     }

     /**
      * returns the position of last character within the supplied text that will
      * fit within the supplied width.
      *
      * @param s
      *            a text string
      * @param f
      *            font used to draw the text string
      * @param w
      *            width in pixles.
      * @param fontHeight
      *            int <b>mapped already to logical units</b>.
      */
     private int getLineWrapPosition(String s, Font f, int w, int fontHeight) {
         if (getTextExtents(s, f, fontHeight).width <= w) {
             return s.length();
         }
         // create an iterator for line breaking positions
         BreakIterator iter = BreakIterator.getLineInstance();
         iter.setText(s);
         int start = iter.first();
         int end = iter.next();

         // if the first line segment does not fit in the width,
         // determine the position within it where we need to cut
         if (getTextExtents(s.substring(start, end), f, fontHeight).width > w) {
             iter = BreakIterator.getCharacterInstance();
             iter.setText(s);
             start = iter.first();
         }

         // keep iterating as long as width permits
         do
             end = iter.next();
         while (end != BreakIterator.DONE
             && getTextExtents(s.substring(start, end), f, fontHeight).width <= w);
         return (end == BreakIterator.DONE) ? iter.last()
             : iter.previous();
     }

     /**
      * Returns the largest substring of <i>s </i> in Font <i>f </i> that can be
      * confined to the number of pixels in <i>availableWidth <i>.
      *
      * @param s
      *            the original string
      * @param f
      *            the font
      * @param w
      *            the available width
      * @param fontHeight
      *            int <b>mapped already to logical units</b>.
      * @param charAverageWidth
      *            int <b>mapped already to logical units</b>.
      * @return the largest substring that fits in the given width
      * @since 2.0
      */
     private int getLargestSubstringConfinedTo(String s, Font f, int w,
             int fontHeight, int charAverageWidth) {
         float avg = charAverageWidth;
         int min = 0;
         int max = s.length() + 1;

         // The size of the current guess
         int guess = 0, guessSize = 0;
         while ((max - min) > 1) {
             // Pick a new guess size
             // New guess is the last guess plus the missing width in pixels
             // divided by the average character size in pixels
             guess = guess + (int) ((w - guessSize) / avg);

             if (guess >= max)
                 guess = max - 1;
             if (guess <= min)
                 guess = min + 1;

             // Measure the current guess
             guessSize = getTextExtents(s.substring(0, guess), f, fontHeight).width;

             if (guessSize < w)
                 // We did not use the available width
                 min = guess;
             else
                 // We exceeded the available width
                 max = guess;
         }
         return min;
     }

     /**
      * Gets the tex extent scaled to the mapping mode
      */
     private Dimension getTextExtents(String s, Font f, int fontHeight) {
         if (s.length() == 0) {
             return getMapModeConstants().dimension_nDPtoLP_0;
         } else {
             // height should be set using the font height and the number of
             // lines in the string
             Dimension d = FigureUtilities.getTextExtents(s, f);
             IMapMode mapMode = getFigureMapMode();
             d.width = mapMode.DPtoLP(d.width);
             d.height = fontHeight * new StringTokenizer(s, "\n").countTokens();//$NON-NLS-1$
             return d;
         }
     }

 }
	/******************************************************************************
	* Copyright (c) 2002, 2009 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Mariot Chauvin <mariot.chauvin@obeo.fr> - bug 272658
	****************************************************************************/

	package org.eclipse.gmf.runtime.draw2d.ui.figures;

	import org.eclipse.draw2d.FigureUtilities;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.geometry.Dimension;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode;
	import org.eclipse.swt.graphics.Font;
	import org.eclipse.swt.graphics.FontMetrics;
	import org.eclipse.swt.graphics.Image;

	import com.ibm.icu.text.BreakIterator;
	import com.ibm.icu.util.StringTokenizer;

	/**
	* An extended label that has the following extra features:
	*
	* 1- It is capable of showing selection and focus feedback (primary or
	* secondary) 2- It is capable of optionally underlining the label's text 3- It
	* is capable of wrapping the label's text at a given width with a given
	* alignment 4- It is capable of supporting multiple label icons (temporary
	* feature)
	*
	* This class was originally deriving off Draw2d's <code>Label</code> class
	* but with the introduction of the auto-wrapping feature, a copy had to be made
	* overriding was not straightforward. Hopefully, this extended version can be
	* pushed to opensource
	*
	* <p>
	* Code taken from Eclipse reference bugzilla #98820
	*
	* @author melaasar, crevells
	* @deprecated This class has been deprecated and may be removed in the future.
	* Use <code>WrappingLabel</code> instead. This class now extends
	* from <code>WrappingLabel</code> so the behavior should be the
	* same. If client code is calling one of the methods on
	* <code>WrapLabel</code> that no longer exists, evaluate whether
	* this is necessary or not.
	*/
	public class WrapLabel
	extends WrappingLabel {

	/** the label's text used in painting after applying required styles */
	private String subStringText;

	/**
	* Construct an empty Label.
	*
	* @since 2.0
	*/
	public WrapLabel() {
	super();
	}

	/**
	* Construct a Label with passed String as its text.
	*
	* @param s
	* the label text
	* @since 2.0
	*/
	public WrapLabel(String s) {
	super(s);

	// Compensate for the fact that the original wraplabel never called the
	// default constructor to set the default layout values.
	setTextWrapAlignment(CENTER);
	}

	/**
	* Construct a Label with passed Image as its icon.
	*
	* @param i
	* the label image
	* @since 2.0
	*/
	public WrapLabel(Image i) {
	super(i);

	// Compensate for the fact that the original wraplabel never called the
	// default constructor to set the default layout values.
	setTextWrapAlignment(CENTER);
	}

	/**
	* Construct a Label with passed String as text and passed Image as its
	* icon.
	*
	* @param s
	* the label text
	* @param i
	* the label image
	* @since 2.0
	*/
	public WrapLabel(String s, Image i) {
	super(s, i);

	// Compensate for the fact that the original wraplabel never called the
	// default constructor to set the default layout values.
	setTextWrapAlignment(CENTER);
	}

	/**
	* Calculates the size of the Label's text size. The text size calculated
	* takes into consideration if the Label's text is currently truncated. If
	* text size without considering current truncation is desired, use
	* {@link #calculateTextSize(int, int)}.
	*
	* @return the size of the label's text, taking into account truncation
	* @since 2.0
	* @deprecated If this behavior is required then a request can be made (with
	* justification) for the WrappingLabel.
	*/
	protected Dimension calculateSubStringTextSize() {
	Font f = getFont();
	return getTextExtents(getSubStringText(), f, getFigureMapMode().DPtoLP(FigureUtilities.getFontMetrics(f).getHeight()));
	}

	/**
	* Calculates and returns the size of the Label's text. Note that this
	* Dimension is calculated using the Label's full text, regardless of
	* whether or not its text is currently truncated. If text size considering
	* current truncation is desired, use {@link #calculateSubStringTextSize()}.
	*
	* @param wHint a width hint
	* @param hHint a height hint
	* @return the size of the label's text, ignoring truncation
	* @since 2.0
	* @deprecated If this behavior is required then a request can be made (with
	* justification) for the WrappingLabel.
	*/
	protected Dimension calculateTextSize(int wHint, int hHint) {
	return getTextFlow().getPreferredSize(wHint, hHint);
	}

	/**
	* Returns the bounds of the Label's icon.
	*
	* @return the icon's bounds
	* @since 2.0
	* @deprecated The icon location can be retrieved with
	* {@link #getIconLocation()} and the icon(s) size can be
	* retrieved with {@link #getTotalIconSize()}.
	*/
	public Rectangle getIconBounds() {
	if (hasIcons()) {
	final Point safeIconLocation = getIconLocation() != null ? getIconLocation() : new Point(0,0);
	return new Rectangle(getBounds().getLocation().translate(
	safeIconLocation), getTotalIconSize());
	}
	return new Rectangle(0, 0, 0, 0);
	}

	/**
	* Calculates the amount of the Label's current text will fit in the Label,
	* including an elipsis "..." if truncation is required.
	*
	* @return the substring
	* @since 2.0
	* @deprecated If this behavior is required then a request can be made (with
	* justification) for the WrappingLabel.
	*/
	public String getSubStringText() {
	if (subStringText != null)
	return subStringText;

	String theText = getText();
	int textLen = theText.length();
	if (textLen == 0) {
	return subStringText = "";//$NON-NLS-1$;;
	}
	Dimension size = getSize();
	Dimension shrink = getPreferredSize(size.width, size.height)
	.getDifference(size);
	Dimension effectiveSize = getTextSize().getExpanded(-shrink.width,
	-shrink.height);

	if (effectiveSize.height == 0) {
	return subStringText = "";//$NON-NLS-1$;
	}

	Font f = getFont();
	FontMetrics metrics = FigureUtilities.getFontMetrics(f);
	IMapMode mm = getFigureMapMode();
	int fontHeight = mm.DPtoLP(metrics.getHeight());
	int charAverageWidth = mm.DPtoLP(metrics.getAverageCharWidth());
	int maxLines = (int) (effectiveSize.height / (double) fontHeight);
	if (maxLines == 0) {
	return subStringText = "";//$NON-NLS-1$
	}

	StringBuffer accumlatedText = new StringBuffer();
	StringBuffer remainingText = new StringBuffer(theText);

	int effectiveSizeWidth = effectiveSize.width;
	int widthHint = Math.max(effectiveSizeWidth
	- getTruncationStringSize().width, 0);
	int i = 0, j = 0;
	while (remainingText.length() > 0 && j++ < maxLines) {
	i = getLineWrapPosition(remainingText.toString(), f,
	effectiveSizeWidth, fontHeight);

	if (accumlatedText.length() > 0)
	accumlatedText.append('\n');

	if (i == 0 \|\| (remainingText.length() > i && j == maxLines)) {
	i = getLargestSubstringConfinedTo(remainingText.toString(), f,
	widthHint, fontHeight, charAverageWidth);
	accumlatedText.append(remainingText.substring(0, i));
	accumlatedText.append(getEllipse());
	} else
	accumlatedText.append(remainingText.substring(0, i));
	remainingText.delete(0, i);
	}
	return subStringText = accumlatedText.toString();
	}

	/**
	* Returns the size of the Label's current text. If the text is currently
	* truncated, the truncated text with its ellipsis is used to calculate the
	* size.
	*
	* @return the size of this label's text, taking into account truncation
	* @since 2.0
	* @deprecated If this behavior is required then a request can be made (with
	* justification) for the WrappingLabel.
	*/
	protected Dimension getSubStringTextSize() {
	return calculateSubStringTextSize();
	}

	/**
	* Returns the location of the label's text relative to the label.
	*
	* @return the text location
	* @since 2.0
	* @deprecated Use <code>getTextBounds().getLocation()</code> instead.
	*/
	protected Point getTextLocation() {
	return getTextBounds().getLocation();
	}

	/**
	* Returns the size of the label's complete text. Note that the text used to
	* make this calculation is the label's full text, regardless of whether the
	* label's text is currently being truncated and is displaying an ellipsis.
	* If the size considering current truncation is desired, call
	* {@link #getSubStringTextSize()}.
	*
	* @param wHint
	* a width hint
	* @param hHint
	* a height hint
	* @return the size of this label's complete text
	* @since 2.0
	* @deprecated If this behavior is required then a request can be made (with
	* justification) for the WrappingLabel.
	*/
	protected Dimension getTextSize(int wHint, int hHint) {
	return getTextFlow().getPreferredSize(wHint, hHint);
	}

	/**
	* Gets the text size given the current size as a width hint
	*/
	private final Dimension getTextSize() {
	Rectangle r = getBounds();
	return getTextSize(r.width, r.height);
	}

	/**
	* @see IFigure#invalidate()
	*/
	public void invalidate() {
	subStringText = null;
	super.invalidate();
	}

	/**
	* Returns <code>true</code> if the label's text is currently truncated
	* and is displaying an ellipsis, <code>false</code> otherwise.
	*
	* @return <code>true</code> if the label's text is truncated
	* @since 2.0
	* @deprecated If this behavior is required then a request can be made (with
	* justification) for the WrappingLabel.
	*/
	public boolean isTextTruncated() {
	return !getSubStringTextSize().equals(getTextSize());
	}

	/**
	* Return the ellipse string.
	*
	* @return the <code>String</code> that represents the fact that the text
	* has been truncated and that more text is available but hidden.
	* Usually this is represented by "...".
	* @deprecated Renamed to {@link #getTruncationString()}
	*/
	protected String getEllipse() {
	return ELLIPSIS;
	}

	protected String getTruncationString() {
	if (getEllipse() != null) {
	return getEllipse();
	}
	return ELLIPSIS;
	}

	/**
	* @return whether the label text wrap is on
	* @deprecated Use {@link #isTextWrapOn()} instead. This method was renamed
	* because it never indicated if the text was actually wrapped,
	* but whether text wrapping was turned on in the label.
	*/
	public boolean isTextWrapped() {
	return isTextWrapOn();
	}

	/**
	* Sets the wrapping width of the label text. This is only valid if text
	* wrapping is turned on
	*
	* @param i
	* The label text wrapping width
	* @deprecated this method was empty and never called
	*/
	public void setTextWrapWidth(int i) {
	// do nothing
	}

	/**
	* Sets the wrapping width of the label text. This is only valid if text
	* wrapping is turned on
	*
	* @param i
	* The label text wrapping width
	* @deprecated Call {@link #setTextJustification(int)} and
	* {@link #setAlignment(int)} instead. This method was somewhat
	* controlling text justification and label alignment, but they
	* are really two independent settings. Previously,
	* setTextWrapAlignment(CENTER) would not only center-justifies
	* the text, but also put the label in the center. Now, you need
	* to call {@link #setTextJustification(int)} to justify the
	* text (this only affects text when it is wrapped) and
	* {@link #setAlignment(int)} to position the text correctly in
	* the label. If you want the text in the center of the label
	* than call <code>setAlignment(PositionConstants.CENTER)</code>.
	* Look at the implementation of this method to see how your
	* code needs to be migrated.
	*/
	public void setTextWrapAlignment(int i) {
	setTextJustification(i);

	// The old WrapLabel's Text Wrap Alignment (i.e. justification) and
	// Label Alignment did not work properly. They worked together
	// previously so we need to compensate for this here.
	switch (i) {
	case LEFT:
	setAlignment(TOP \| LEFT);
	break;
	case CENTER:
	setAlignment(TOP);
	break;
	case RIGHT:
	setAlignment(TOP \| RIGHT);
	break;
	default:
	break;
	}
	}

	/**
	* @deprecated This never worked properly anyways. Call
	* {@link #setAlignment(int)} instead to position the icon and
	* text within the label.
	*/
	public void setLabelAlignment(int alignment) {
	// setLabelAlignment() never worked properly instead the label alignment
	// seemed to be based on the text justification. Therefore, if it was
	// set it will be ignored.
	}

	/**
	* @return the label text wrapping width
	* @deprecated Renamed to {@link #getTextJustification()}
	*/
	public int getTextWrapAlignment() {
	return getTextJustification();
	}

	/**
	* returns the position of last character within the supplied text that will
	* fit within the supplied width.
	*
	* @param s
	* a text string
	* @param f
	* font used to draw the text string
	* @param w
	* width in pixles.
	* @param fontHeight
	* int <b>mapped already to logical units</b>.
	*/
	private int getLineWrapPosition(String s, Font f, int w, int fontHeight) {
	if (getTextExtents(s, f, fontHeight).width <= w) {
	return s.length();
	}
	// create an iterator for line breaking positions
	BreakIterator iter = BreakIterator.getLineInstance();
	iter.setText(s);
	int start = iter.first();
	int end = iter.next();

	// if the first line segment does not fit in the width,
	// determine the position within it where we need to cut
	if (getTextExtents(s.substring(start, end), f, fontHeight).width > w) {
	iter = BreakIterator.getCharacterInstance();
	iter.setText(s);
	start = iter.first();
	}

	// keep iterating as long as width permits
	do
	end = iter.next();
	while (end != BreakIterator.DONE
	&& getTextExtents(s.substring(start, end), f, fontHeight).width <= w);
	return (end == BreakIterator.DONE) ? iter.last()
	: iter.previous();
	}

	/**
	* Returns the largest substring of <i>s </i> in Font <i>f </i> that can be
	* confined to the number of pixels in <i>availableWidth <i>.
	*
	* @param s
	* the original string
	* @param f
	* the font
	* @param w
	* the available width
	* @param fontHeight
	* int <b>mapped already to logical units</b>.
	* @param charAverageWidth
	* int <b>mapped already to logical units</b>.
	* @return the largest substring that fits in the given width
	* @since 2.0
	*/
	private int getLargestSubstringConfinedTo(String s, Font f, int w,
	int fontHeight, int charAverageWidth) {
	float avg = charAverageWidth;
	int min = 0;
	int max = s.length() + 1;

	// The size of the current guess
	int guess = 0, guessSize = 0;
	while ((max - min) > 1) {
	// Pick a new guess size
	// New guess is the last guess plus the missing width in pixels
	// divided by the average character size in pixels
	guess = guess + (int) ((w - guessSize) / avg);

	if (guess >= max)
	guess = max - 1;
	if (guess <= min)
	guess = min + 1;

	// Measure the current guess
	guessSize = getTextExtents(s.substring(0, guess), f, fontHeight).width;

	if (guessSize < w)
	// We did not use the available width
	min = guess;
	else
	// We exceeded the available width
	max = guess;
	}
	return min;
	}

	/**
	* Gets the tex extent scaled to the mapping mode
	*/
	private Dimension getTextExtents(String s, Font f, int fontHeight) {
	if (s.length() == 0) {
	return getMapModeConstants().dimension_nDPtoLP_0;
	} else {
	// height should be set using the font height and the number of
	// lines in the string
	Dimension d = FigureUtilities.getTextExtents(s, f);
	IMapMode mapMode = getFigureMapMode();
	d.width = mapMode.DPtoLP(d.width);
	d.height = fontHeight * new StringTokenizer(s, "\n").countTokens();//$NON-NLS-1$
	return d;
	}
	}

	}