/*
    * 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.Insets;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.HierarchyEvent;
  import java.awt.event.HierarchyListener;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.JTextField;
  import javax.swing.text.Document;
  
  
  /**
   * Descedant of JTextField that implements font resizing. When in resize mode,
   * the field automatically adjusts its text font size to fit best into the
   * space available. By default resizing is off.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   *
   * @see javax.swing.JTextField
   */
  public class ResizableTextField extends JTextField
  {
  	private static final long serialVersionUID = 1L;
  	private boolean resizable;
  	private boolean enhanced;
  	private Dimension preferredSize;
  	private Dimension minimumSize;
  	private Font userFont;
  	private final Logger logger = DebugLogger.getLogger("RTF", Level.OFF);
  
  	/**
  	 * Creates an empty resizable text field.
  	 */
  	public ResizableTextField()
  	{
  		this(null, null, 0);
  	}
  
  	/**
  	 * Creates a resizable text field with text.
  	 *
  	 * @param arg0 String
  	 */
  	public ResizableTextField(String arg0)
  	{
  		this(null, arg0, 0);
  	}
  
  	/**
  	 * Creates a resizable text field with specified number of columns.
  	 *
  	 * @param arg0 int
  	 */
  	public ResizableTextField(int arg0)
  	{
  		this(null, null, arg0);
  	}
  
  	/**
  	 * Creates a resizable text field with text and specified number of
  	 * columns.
  	 *
  	 * @param arg0 document to be used for parsing strings.
  	 * @param arg1 int
 	 */
 	public ResizableTextField(String arg0, int arg1)
 	{
 		this(null, arg0, arg1);
 	}
 
 	/**
 	 * Creates a resizable text field with document, text and specified number
 	 * of columns.
 	 *
 	 * @param arg0 document to be used for parsing strings.
 	 * @param arg1 text
 	 * @param arg2 number of columns
 	 */
 	public ResizableTextField(Document arg0, String arg1, int arg2)
 	{
 		super(arg0, arg1, arg2);
 		addComponentListener(new ResizableComponentAdapter());
 		addHierarchyListener(new ResizableComponentAdapter());
 		addKeyListener(new ResizableKeyAdapter());
 		setFont(FontHelper.getDefaultFont());
 	}
 
 	/**
 	 * Returns the resizable setting.
 	 *
 	 * @return boolean
 	 */
 	public boolean isResizable()
 	{
 		return resizable;
 	}
 
 	/**
 	 * Sets whether the ResizableTextField should adjust its font size
 	 * according to the size of the component.
 	 *
 	 * @param newResizable boolean
 	 */
 	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());
 			}
 
 			//doLayout();
 			//repaint();
 		}
 	}
 
 	/**
 	 * Sets the enhanced mode setting. When true, the text field 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;
 	}
 
 	/**
 	 * Bugfix for bug 4243496
 	 *
 	 * @param margin Insets
 	 *
 	 * @see javax.swing.text.JTextComponent#setMargin(java.awt.Insets)
 	 */
 	public void setMargin(Insets margin)
 	{
 		if (margin == null) {
 			super.setMargin(new Insets(0, 2, 0, 2));
 
 			return;
 		}
 
 		if (margin.left == 0) {
 			super.setMargin(new Insets(margin.top, 2, margin.bottom,
 			        margin.right));
 
 			return;
 		}
 
 		super.setMargin(margin);
 	}
 
 	/**
 	 * This method was overloaded to implement font resizing.
 	 *
 	 * @param text String
 	 *
 	 * @see JTextField#setText(String)
 	 */
 	public void setText(String text)
 	{
 		if (logger!=null) logger.info("text='" + text + "'");
 		super.setText(text);
 		//revalidate();
 
 		//resize();
 	}
 
 	/**
 	 * Adjusts the size of the font to the size of the text field. It is safe
 	 * to call this method without checking if field is in fact resizable.
 	 */
 	protected void resize()
 	{
 		if (!isResizable()) {
 			return;
 		}
 
 		//Thread.dumpStack();
 		logger.fine("resizing");
 
 		/*int size = calculateFontSize(getSize(), getText());
 
 		if (size == getFont().getSize()) {
 		    logger.fine("size not changed "+size);
 		    return;
 		}
 
 		logger.fine("new size "+size);
 		super.setFont(FontHelper.getFontWithSize(size, getFont()));*/
 		Font f = FontHelper.calculateFittingFont(this, getFont(), getText(),
 			    getColumns(), 0, Integer.MAX_VALUE);
 
 		if (f != getFont()) {
 			logger.fine("font resized to " + f.getSize() + " from "
 			    + getFont().getSize());
 			super.setFont(f);
 		}
 	}
 
 	/*
 	 * Calculates new size of font for textto matcch available space.
 	 *
 	 * @return int
 	 */
 	/*protected int calculateFontSize(Dimension dim, String text)
 	{
 	    // ideal size from vert evaluation
 	    int vSize = Math.max((dim.height * 14) / 20,
 	            FontHelper.getDefaultFontSize());
 
 	    int l = (text != null)
 	        ? getFontMetrics(FontHelper.getDefaultFont()).stringWidth(text)
 	        : (getFontMetrics(FontHelper.getDefaultFont()).stringWidth("m") * getColumns());
 
 	    // ideal size from vert evaluation
 	    int hSize = (int)((dim.width * 0.9) / l * FontHelper.getDefaultFontSize());
 
 	    int s = Math.min(vSize, hSize);
 	    s = Math.max(s, 1);
 
 	    return s;
 	}*/
 
 	/**
 	 * This method was overloaded to implement font resizing.
 	 *
 	 * @return Dimension
 	 *
 	 * @see JTextField#getPreferredSize()
 	 */
 	public Dimension getPreferredSize()
 	{
 		if (preferredSize != null) {
 			return preferredSize;
 		}
 
 		Font font = FontHelper.getDefaultFont();
 		int height = (font.getSize() * 20) / 13;
 		int width = (getColumns() * getFontMetrics(font).stringWidth("m") * 10) / 8;
 
 		return new Dimension(Math.max(width, 1), Math.max(height, 1));
 	}
 
 	/**
 	 * This method was overloaded 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;
 		}
 
 		Font font = FontHelper.getDefaultFont();
 		int height = (font.getSize() * 20) / 13;
 		int width = (getColumns() * getFontMetrics(font).stringWidth("m") * 10) / 8;
 
 		return new Dimension(Math.max(width, 1), Math.max(height, 1));
 	}
 
 	/**
 	 * 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 text field.
 	 *
 	 * @param g Graphics
 	 *
 	 * @see javax.swing.JComponent#paintComponent(Graphics)
 	 */
 	protected void paintComponent(Graphics g)
 	{
 		//Thread.dumpStack();
 		logger.fine("painting");
 
 		if (enhanced) {
 			((Graphics2D)g).addRenderingHints(PaintHelper.getAntialiasingHints());
 		}
 
 		super.paintComponent(g);
 	}
 
 	/**
 	 * This method was overriden to support resizing and user supplied fonts.
 	 * In resizable mode, this setting is ignored.
 	 *
 	 * @see java.awt.Component#setFont(java.awt.Font)
 	 */
 	public void setFont(Font f)
 	{
 		userFont = f;
 		super.setFont(f);
 	}
 
 	/**
 	 * Listens for ComponentEvents and notifies text resizing if enabled.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class ResizableComponentAdapter extends ComponentAdapter implements HierarchyListener
 	{
 		/**
 		 * Invokes text resizing if enabled when component is resized.
 		 *
 		 * @param e ComponentEvent
 		 *
 		 * @see java.awt.event.ComponentListener#componentResized(ComponentEvent)
 		 */
 		public void componentResized(ComponentEvent e)
 		{
 			logger.finest("resize event " + e);
 			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) {
 			resize();			
 		}
 	}
 
 	/**
 	 * Listens for KeyEvents and resizes the text if enabled.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class ResizableKeyAdapter extends KeyAdapter
 	{
 		/**
 		 * Invokes text resizing if enabled while text is typed.
 		 *
 		 * @param e
 		 *
 		 * @see java.awt.event.KeyListener#keyTyped(java.awt.event.KeyEvent)
 		 */
 		public void keyReleased(KeyEvent e)
 		{
 			if (resizable) {
 				revalidate();
 				resize();
 			}
 		}
 	}
 }
 
 /* __oOo__ */