/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import com.cosylab.gui.components.util.FontHelper;
  import com.cosylab.gui.components.util.PaintHelper;
  
  import com.cosylab.logging.DebugLogger;
  
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.HierarchyEvent;
  import java.awt.event.HierarchyListener;
  
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.Icon;
  import javax.swing.JLabel;
  import javax.swing.SwingConstants;
  
  
  /**
   * A text area in which the text can dynamicaly adjust its font size to fill
   * the whole area available. By default resizing is turn off.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   *
   * @see javax.swing.JLabel
   */
  public class ResizableTextLabel extends JLabel
  {
  	private static final long serialVersionUID = 1L;
  	private boolean resizable;
  	private boolean enhanced;
  	private int columns;
  	private Dimension preferredSize;
  	private Dimension minimumSize;
  	private Font userFont;
  	private int minFontSize = 0;
  	private int maxFontSize = Integer.MAX_VALUE;
  	private final Logger logger = DebugLogger.getLogger("RTL",
  		    Level.OFF);
  
  	/**
  	 * Helper class that notifies the resizable text label to  resize its font
  	 * when itself is being resized.
  	 *
  	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
  	 * @version $id$
  	 *
  	 * @see java.awt.event.ComponentAdapter
  	 */
  	protected class ResizableAdapter extends ComponentAdapter implements HierarchyListener
  	{
  		/**
  		 * Invoked when the label is being resized.
  		 *
  		 * @param e ComponentEvent
  		 *
  		 * @see java.awt.event.ComponentListener#componentResized(ComponentEvent)
  		 */
  		public void componentResized(ComponentEvent e)
  		{
  			if (resizable) {
  				resize();
  			}
  		}
  		
  		/**
  		 * Invoke resizing of the font when the hiearachy changes, because this
  		 * action might as well change the size of the components, but the resize
  		 * is not fired, because the component did not have parent prior to that.
  		 * 
  		 * @param e the event describing the hierarchy change
  		 */
  		public void hierarchyChanged(HierarchyEvent e) {
 			if (resizable) {
 				resize();
 			}
 			
 		}
 		
 		
 	}
 
 	/**
 	 * Creates a resizable text label with text, icon and  predefined
 	 * horizontal text aligment and resizable  font setting.
 	 *
 	 * @param text java.lang.String text to be displayed in  the label.
 	 * @param icon Icon image to be displayed in the label.
 	 * @param horizontalAlignment int horizontal aligment of the text in the
 	 *        label.
 	 */
 	public ResizableTextLabel(String text, Icon icon, int horizontalAlignment)
 	{
 		super(text, icon, horizontalAlignment);
 		addComponentListener(new ResizableAdapter());
 		addHierarchyListener(new ResizableAdapter());
 		setFont(FontHelper.getDefaultFont());
 	}
 
 	/**
 	 * Creates a resizable text label with text and predefined  horizontal text
 	 * aligment.
 	 *
 	 * @param arg0 java.lang.String text to be displayed in  the label.
 	 * @param arg1 int horizontal aligment of the text in the  label.
 	 */
 	public ResizableTextLabel(String arg0, int arg1)
 	{
 		this(arg0, null, arg1);
 	}
 
 	/**
 	 * Creates a resizable text label with text.
 	 *
 	 * @param arg0 java.lang.String text to be displayed in  the label.
 	 */
 	public ResizableTextLabel(String arg0)
 	{
 		this(arg0, null, SwingConstants.LEADING);
 	}
 
 	/**
 	 * Creates a resizable text label with icon and  predefined horizontal text
 	 * aligment and resizable  font setting.
 	 *
 	 * @param image Icon image to be displayed in the label.
 	 * @param horizontalAlignment int horizontal aligment of the text in the
 	 *        label.
 	 */
 	public ResizableTextLabel(Icon image, int horizontalAlignment)
 	{
 		this(null, image, horizontalAlignment);
 	}
 
 	/**
 	 * Creates a resizable text label with an icon
 	 *
 	 * @param image Icon image to be displayed in the label.
 	 */
 	public ResizableTextLabel(Icon image)
 	{
 		this(null, image, SwingConstants.LEADING);
 	}
 
 	/**
 	 * Creates an empty label.
 	 */
 	public ResizableTextLabel()
 	{
 		this(" ", null, SwingConstants.LEADING);
 	}
 
 	/**
 	 * Sets the number of character columns to be displayed. This setting only
 	 * has effect if resizable text font setting is enabled. Then the size of
 	 * the font is adjusted to display the specified number of character
 	 * columns.
 	 *
 	 * @param newColumns
 	 */
 	public void setColumns(int newColumns)
 	{
 		int oldColumns = columns;
 
 		if (oldColumns == newColumns) {
 			return;
 		}
 
 		columns = newColumns;
 		firePropertyChange("columns", oldColumns, newColumns);
 
 		if (resizable) {
 			resize();
 		}
 	}
 
 	/**
 	 * Gets the number of character columns to be displayed.
 	 *
 	 * @return int
 	 */
 	public int getColumns()
 	{
 		return columns;
 	}
 
 	/**
 	 * Returns the resizable text font setting.
 	 *
 	 * @return boolean
 	 */
 	public boolean isResizable()
 	{
 		return resizable;
 	}
 
 	/**
 	 * Sets the resizable text font setting.
 	 *
 	 * @param newResizable
 	 */
 	public void setResizable(boolean newResizable)
 	{
 		boolean oldResizable = resizable;
 
 		if (oldResizable == newResizable) {
 			return;
 		}
 
 		resizable = newResizable;
 		firePropertyChange("resizable", oldResizable, newResizable);
 
 		if (resizable) {
 			resize();
 		} else {
 			if (userFont != null) {
 				super.setFont(userFont);
 			} else {
 				super.setFont(FontHelper.getDefaultFont());
 			}
 		}
 	}
 
 	/**
 	 * Sets the enhanced mode setting. When true, the label is painted with
 	 * anti-aliasing rendering hints.
 	 *
 	 * @param newEnhanced
 	 */
 	public void setEnhanced(boolean newEnhanced)
 	{
 		boolean oldEnhanced = enhanced;
 
 		if (oldEnhanced == newEnhanced) {
 			return;
 		}
 
 		enhanced = newEnhanced;
 		firePropertyChange("enhanced", oldEnhanced, newEnhanced);
 		repaint();
 	}
 
 	/**
 	 * Returns the enhanced mode setting.
 	 *
 	 * @return boolean
 	 */
 	public boolean isEnhanced()
 	{
 		return enhanced;
 	}
 
 	/**
 	 * This method was overriden to implement font resizing.
 	 *
 	 * @param text to be displayed.
 	 *
 	 * @see javax.swing.JLabel#setText(String)
 	 */
 	public void setText(String text)
 	{
 		if (text != null && text.length() < 1) {
 			text = " ";
 		}
 
 		super.setText(text);
 
 		if (resizable) {
 			resize();
 		}
 	}
 
 	/**
 	 * (This method may improve usage of columns field)  This method sets font
 	 * size and columns to make this label fit to display wanted amount of
 	 * characters in preferred font size. If string represented by text field
 	 * is longer than expected, label still displays it, just fontsize is
 	 * changed  (only if resizable); !!Event listeners should listen to
 	 * component resized event to avoid some problems with fitting this label
 	 * in the parent container.!!
 	 *
 	 * @param fontSize preferred font size
 	 * @param newColumns columns of text to display
 	 */
 	public void adjustSizeToFont(int fontSize, int newColumns)
 	{
 		Font font = FontHelper.getFontWithSize(fontSize, getFont());
 		int length = getFontMetrics(font).stringWidth("m") * newColumns;
 
 		super.setSize((int)(length / 0.9), fontSize * (20 / 14));
 		setColumns(newColumns);
 
 		//resize() is called by setColumns(..) or setSize(..).
 		if (!resizable) {
 			super.setFont(font);
 		}
 	}
 
 	protected void resize()
 	{
 		logger.fine("resizing");
 
 		Font f = FontHelper.calculateFittingFont(this, getFont(), getText(),
 			    columns, minFontSize, maxFontSize);
 
 		if (f != getFont()) {
 			super.setFont(f);
 		}
 	}
 
 	/**
 	 * This method was overriden to implement font resizing.
 	 *
 	 * @see javax.swing.JComponent#addNotify()
 	 */
 	public void addNotify()
 	{
 		super.addNotify();
 
 		if (resizable) {
 			resize();
 		}
 	}
 
 	/**
 	 * This method was overriden to implement font resizing.
 	 *
 	 * @return Dimension preferred size of the label
 	 *
 	 * @see javax.swing.JLabel#getPreferredSize()
 	 */
 	public Dimension getPreferredSize()
 	{
 		if (preferredSize != null) {
 			return preferredSize;
 		} else if (resizable) {
 			Font font;
 
 			if (userFont == null) {
 				font = FontHelper.getDefaultFont();
 			} else {
 				font = userFont;
 			}
 
 			int height = font.getSize() * 20 / 13;
 			int width = getFontMetrics(font).stringWidth("m") * 10 / 8 * columns;
 
 			if (columns == 0 && getText() != null) {
 				width = getFontMetrics(font).stringWidth(getText()) * 10 / 8;
 			}
 
 			if (width == 0) {
 				width = 1;
 			}
 
 			return new Dimension(width, height);
 		} else {
 			return super.getPreferredSize();
 		}
 	}
 
 	/**
 	 * This method was overriden to implement font resizing.
 	 *
 	 * @see javax.swing.JComponent#setPreferredSize(Dimension)
 	 */
 	public void setPreferredSize(Dimension newPreferredSize)
 	{
 		preferredSize = newPreferredSize;
 		super.setPreferredSize(newPreferredSize);
 	}
 
 	/**
 	 * This method was overriden to implement font resizing.
 	 *
 	 * @see java.awt.Component#getMinimumSize()
 	 */
 	public Dimension getMinimumSize()
 	{
 		if (minimumSize != null) {
 			return minimumSize;
 		} else if (resizable) {
 			return getPreferredSize();
 		} else {
 			return super.getMinimumSize();
 		}
 	}
 
 	/**
 	 * This method was overriden to implement font resizing.
 	 *
 	 * @see javax.swing.JComponent#setMinimumSize(Dimension)
 	 */
 	public void setMinimumSize(Dimension newMinimumSize)
 	{
 		minimumSize = newMinimumSize;
 		super.setMinimumSize(newMinimumSize);
 	}
 
 	/**
 	 * This method hes been overriden to implement the feature  of enhanced
 	 * anti-aliasing paint of the label.
 	 *
 	 * @see javax.swing.JComponent#paintComponent(Graphics)
 	 */
 	protected void paintComponent(Graphics g)
 	{
 		logger.fine("painting");
 
 		if (enhanced) {
 			((Graphics2D)g).addRenderingHints(PaintHelper.getAntialiasingHints());
 		}
 
 		super.paintComponent(g);
 	}
 
 	/**
 	 * Returns maximum font size text can reach.
 	 *
 	 * @return maximum font size text can reach
 	 */
 	public int getMaximumFontSize()
 	{
 		return maxFontSize;
 	}
 
 	/**
 	 * Returns minimum font size text can reach.
 	 *
 	 * @return minimum font size text can reach
 	 */
 	public int getMinimumFontSize()
 	{
 		return minFontSize;
 	}
 
 	/**
 	 * Sets maximum font size text can reach.
 	 *
 	 * @param newMax new maximum font size text can reach
 	 */
 	public void setMaximumFontSize(int newMax)
 	{
 		int oldMax = maxFontSize;
 
 		if (oldMax == newMax) {
 			return;
 		}
 
 		maxFontSize = newMax;
 		firePropertyChange("maximumFontSize", oldMax, newMax);
 		resize();
 	}
 
 	/**
 	 * minimum font size text can reach
 	 *
 	 * @param newMin new minimum font size text can reach
 	 */
 	public void setMinimumFontSize(int newMin)
 	{
 		int oldMin = minFontSize;
 
 		if (oldMin == newMin) {
 			return;
 		}
 
 		minFontSize = newMin;
 		firePropertyChange("minimumFontSize", oldMin, newMin);
 		resize();
 	}
 }
 
 /* __oOo__ */