utils/eclipselink.utils.workbench/uitools/source/org/eclipse/persistence/tools/workbench/uitools/LabelArea.java

/*******************************************************************************
 * Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.tools.workbench.uitools;

import java.awt.Color;
import java.awt.Dimension;
import javax.accessibility.AccessibleContext;
import javax.swing.Icon;
import javax.swing.JLabel;
import javax.swing.plaf.basic.BasicHTML;
import javax.swing.text.BoxView;
import javax.swing.text.View;
import javax.swing.text.html.CSS;
import org.eclipse.persistence.tools.workbench.utility.ClassTools;
import org.eclipse.persistence.tools.workbench.utility.string.StringTools;

/**
 * This <code>LabelArea</code> allows the text to be wrapped automatically using
 * an HTML view. {@link #getOriginalText()} returns the text that was passed to
 * {@link #setText(String)}, which is the non-modified string; {@link #getText()}
 * actually returns the HTML formatted string.
 * <p>
 * By default, the text is not scrollable, which means it'll use the preferred
 * width to calculate its size. When scrollable is <code>true</code>, then the
 * text wraps based on the available width.
 *
 * @version 11.0.0
 * @since 9.0.4
 */
public class LabelArea extends JLabel
{
	/**
	 * Internal flag used to prevent an infinite loop between setText() and
	 * setDisplayMnemonicIndex().
	 */
	private boolean locked;

	/**
	 * The text before it has been formatted as an HTML string.
	 */
	private String originalText;

	/**
	 * The maximum width this label should have. The width is used to calculate
	 * the preferred height.
	 * @see #PREFERRED_WIDTH
	 */
	private int preferredWidth = PREFERRED_WIDTH;

	/**
	 * Determines if the text shoudl wrap based on the available width. The
	 * default value is <code>false</code>.
	 */
	private boolean scrollable;

	/**
	 * The default preferred width used to calculate the size of this label.
	 * The default value is 300.
	 */
	public static final int PREFERRED_WIDTH = 300;

	/**
	 * Creates a new <code>LabelArea</code>.
	 */
	public LabelArea()
	{
		super();
	}

	/**
	 * Creates a new <code>LabelArea</code>.
	 *
	 * @param icon The icon displayed by this label, <code>null</code> is also
	 * valid
	 */
	public LabelArea(Icon icon)
	{
		super(icon);
	}

	/**
	 * Creates a new <code>LabelArea</code>.
	 *
	 * @param icon The icon displayed by this label, <code>null</code> is also
	 * valid
	 * @param horizontalAlignment One of the following constants defined in
	 * <code>SwingConstants</code>: <code>LEFT</code>, <code>CENTER</code>,
	 * <code>RIGHT</code>, <code>LEADING</code> or <code>TRAILING</code>.
	 */
	public LabelArea(Icon icon, int horizontalAlignment)
	{
		super(icon, horizontalAlignment);
	}

	/**
	 * Creates a new <code>LabelArea</code>.
	 *
	 * @param text This label's text
	 */
	public LabelArea(String text)
	{
		super(text);
	}

	/**
	 * Creates a new <code>LabelArea</code>.
	 *
	 * @param text This label's text
	 * @param icon The icon displayed by this label, <code>null</code> is also
	 * valid
	 * @param horizontalAlignment One of the following constants defined in
	 * <code>SwingConstants</code>: <code>LEFT</code>, <code>CENTER</code>,
	 * <code>RIGHT</code>, <code>LEADING</code> or <code>TRAILING</code>.
	 */
	public LabelArea(String text, Icon icon, int horizontalAlignment)
	{
		super(text, icon, horizontalAlignment);
	}

	/**
	 * Creates a new <code>LabelArea</code>.
	 *
	 * @param text This label's text
	 * @param horizontalAlignment One of the following constants defined in
	 * <code>SwingConstants</code>: <code>LEFT</code>, <code>CENTER</code>,
	 * <code>RIGHT</code>, <code>LEADING</code> or <code>TRAILING</code>.
	 */
	public LabelArea(String text, int horizontalAlignment)
	{
		super(text, horizontalAlignment);
	}

	/**
	 * Formats the given string into HTML using the given properties.
	 *
	 * @param text The actual text to be formatted into HTML
	 * @return The HTML formatted text using the given properties or the given
	 * text if is already an HTML formatted string
	 */
	private String convertToHTML()
	{
		// Nothing to format
		if (StringTools.stringIsEmpty(originalText) ||
			 BasicHTML.isHTMLString(originalText))
		{
			return originalText;
		}

		StringBuilder sb = new StringBuilder();
		sb.append("<HTML><BODY");

		if (!isEnabled())
		{
			Class<?>[] parameterTypes = new Class<?>[] { Color.class };
			Object[] parameterValues = new Object[] { getBackground().darker() };
			String foregroundColor = (String) ClassTools.invokeStaticMethod(CSS.class, "colorToHex", parameterTypes, parameterValues);

			sb.append(" TEXT=\"");
			sb.append(foregroundColor);
			sb.append("\"");
		}

		sb.append(">");

		// If the mnemonic is set, then wraps it with <u></u>
		int mnemonicIndex = getDisplayedMnemonicIndex();

		if (mnemonicIndex > -1)
		{
			sb.append(originalText.substring(0, mnemonicIndex));
			sb.append("<U>");
			sb.append(originalText.charAt(mnemonicIndex));
			sb.append("</U>");
			sb.append(originalText.substring(mnemonicIndex + 1));
		}
		else
		{
			sb.append(originalText);
		}

		sb.append("</BODY></HTML>");

		return sb.toString();
	}

	/*
	 * (non-Javadoc)
	 */
	private int findDisplayedMnemonicIndex()
	{
		int mnemonic = getDisplayedMnemonic();

		if ((originalText == null) || (mnemonic == '\0'))
			return -1;

		char uc = Character.toUpperCase((char) mnemonic);
		char lc = Character.toLowerCase((char) mnemonic);

		int uci = originalText.indexOf(uc);
		int lci = originalText.indexOf(lc);

		if (uci == -1)
			return lci;

		if (lci == -1)
			return uci;

		return (lci < uci) ? lci : uci;
	}

	/*
	 * (non-Javadoc)
	 */
	@Override
	public AccessibleContext getAccessibleContext()
	{
		if (accessibleContext == null)
			accessibleContext = new AccessibleLabelArea();

		return accessibleContext;
	}

	/**
	 * Returns the text prior to be formatted as an HTML string. If the string is
	 * already formatted, then this one is returned.
	 *
	 * @return The original string passed to {@link #setText(String)}
	 */
	public String getOriginalText()
	{
		return originalText;
	}

	/*
	 * (non-Javadoc)
	 */
	@Override
	public Dimension getMinimumSize()
	{
		return getPreferredSize();
	}

	/*
	 * (non-Javadoc)
	 */
	@Override
	public Dimension getPreferredSize()
	{
		View rootView = (View) getClientProperty(BasicHTML.propertyKey);

		if ((rootView != null) && !isPreferredSizeSet())
		{
			BoxView view = (BoxView) rootView.getView(0);

			if (scrollable)
			{
				int width  = (int) rootView.getMinimumSpan(View.X_AXIS);
				int height = (int) rootView.getMinimumSpan(View.Y_AXIS);

				Dimension size = super.getPreferredSize();
				size.width  = Math.min(width,  size.width);
				size.height = Math.max(height, size.height);
				return size;
			}
			else
			{
				float width = Math.min((int) view.getPreferredSpan(View.X_AXIS), preferredWidth);
				view.setSize(width, 0.0f);

				float height = view.getPreferredSpan(View.Y_AXIS);
				rootView.setSize(width, height);
			}
		}

		return super.getPreferredSize();
	}

	/**
	 * Returns the maximum width this label should have. The width is used to
	 * calculate the preferred height.
	 *
	 * @return A positive value that fixes the width of this label
	 * @see #PREFERRED_WIDTH
	 */
	public int getPreferredWidth()
	{
		return preferredWidth;
	}

	/*
	 * (non-Javadoc)
	 */
	@Override
	public void setDisplayedMnemonicIndex(int index) throws IllegalArgumentException
	{
		if (locked)
			return;

		try
		{
			locked = true;
			super.setDisplayedMnemonicIndex(index);
		}
		finally
		{
			locked = false;
		}

		setText(originalText);
	}

	/**
	 * Sets the maximum width this label should have. The width is used to
	 * calculate the preferred height. The default is value is 300.
	 *
	 * @return A positive value that fixes the width of this label
	 * @exception IllegalArgumentException The preferred width cannot be negative
	 */
	public void setPreferredWidth(int preferredWidth)
	{
		if (preferredWidth < 0)
		{
			throw new IllegalArgumentException("Preferred width cannot be negative");
		}

		this.preferredWidth = preferredWidth;
	}

   /**
	 * Determines if the text should wrap based on the available width. The
	 * default value is <code>false</code>.
	 *
	 * @param scrollabe <code>true</code> to let the text wrap automatically
	 * when the size changes; <code>false</code> otherwise to fix its width and
	 * height based on {@link #preferredWidth}
	 */
	public void setScrollable(boolean scrollable)
	{
		this.scrollable = scrollable;
	}

   /**
	 * Sets the text of this <code>LabelArea</code> to the specified value. The
	 * string will automatically be converted into an HTML string if it's not
	 * already one. The original string, not formatted, can be retrieved
	 * with {@link #getActualText()}.
	 *
	 * @param text The new text to be set
	 * @see javax.swing.JLabel#setText(String)
	 */
	@Override
	public void setText(String text)
	{
		this.originalText = text;
		text = convertToHTML();

		try
		{
			locked = true;
			super.setText(text);
			super.setDisplayedMnemonicIndex(findDisplayedMnemonicIndex());
		}
		finally
		{
			locked = false;
		}
	}

	/**
	 * This class implements accessibility support for the <code>LabelArea</code>
	 * class, the accessible name will be returned non-HTML formatted.
	 */
	protected class AccessibleLabelArea extends AccessibleJLabel
	{
		@Override
		public String getAccessibleName()
		{
			if (accessibleName != null)
				return accessibleName;

			if (LabelArea.this.originalText == null)
				return null;

			// The regular expression supports: <br>, <br />, <p>, </p>
			// and any cases of each letter
			return LabelArea.this.originalText.replaceAll("<[Bb][Rr](\\s)?(/)?>|<(/)?[Pp]>", " "); //$NON-NLS-2$
		}
	}
}