/*

 Wotonomy: OpenStep design patterns for pure Java applications.

 Copyright (C) 2000 Michael Powers

 This library is free software; you can redistribute it and/or

 modify it under the terms of the GNU Lesser General Public

 License as published by the Free Software Foundation; either

 version 2.1 of the License, or (at your option) any later version.

 This library 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

 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public

 License along with this library; if not, see http://www.gnu.org

 */

 package net.wotonomy.ui.swing.util;

 import java.awt.Component;

 import java.awt.Container;

 import java.awt.Dialog;

 import java.awt.Dimension;

 import java.awt.Point;

 import java.awt.Toolkit;

 import java.awt.Window;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 /**

 * A collection of window-related utilities.

 *

 * @author michael@mpowers.net

 * @author $Author: cgruber $

 * @version $Revision: 904 $

 * $Date: 2006-02-18 23:19:05 +0000 (Sat, 18 Feb 2006) $

 *

 */

 public class WindowUtilities

 {

 /**

 * Place frame at center (vertically and horizontally) of screen.

 */

     public static final int CENTER = 0;

 /**

 * Center dialog on frame area of parent, if any.

 */

     public static final int CENTER_PARENT = 1;

 /**

 * Place lower and to the right of the last window

 * placed in this manner.  Will wrap to top and left

 * of screen as necessary.

 */

     public static final int CASCADE = 10;

     // cascade state

     private static int lastX = 0;

     private static int lastY = 0;

     private static int incrementX = 20;

     private static int incrementY = 20;

 /**

 * Place the window in the center of the screen.

 * Note: don't forget to first set the size of your window.

 * This is a convenience method and simply calls place() with

 * the CENTER parameter.

 * @param aWindow The window to be centered.

 * @see #place

 */

     public static void center( Window aWindow )

     {

         place( aWindow, CENTER );

     }

 /**

 * Place lower and to the right of the last window

 * placed in this manner.  Will wrap to top and left

 * of screen as necessary.

 * This is a convenience method and simply calls place() with

 * the CASCADE parameter.

 * @param aWindow The window to be cascaded.

 * @see #place

 */

     public static void cascade( Window aWindow )

     {

         place( aWindow, CASCADE );

     }

 /**

 * Place the window in the specified location.

 * Note: don't forget to first set the size of your window.

 * @param aWindow The window to be placed.

 * @param location Where on screen to place the frame.

 */

     public static void place( Window aWindow, int location)

     {

         Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

         Dimension mySize = aWindow.getSize();

         int x = (aWindow.getLocation()).x;

         int y = (aWindow.getLocation()).y;

         float aspectRatio = (float)screenSize.height/(float)screenSize.width;

         // hack to make windows appear on left monitor if dual monitor

         // if aspect ratio is less than 0.6, assume dual monitor

         if (aspectRatio < 0.6)

         {

             screenSize.width = screenSize.width/2;

         }

         switch (location)

         {

           case CENTER_PARENT:

                   if ( ( ! ( aWindow instanceof Dialog ) )

                   ||  ( ((Dialog)aWindow).getParent() == null ) )

 //1.2                  ||  ( ((Dialog)aWindow).getOwner() == null ) )

                   {

                     place( aWindow, CENTER );

                     return;

                   }

                   Point parentLocation = (((Dialog)aWindow).getParent()).getLocation();

 //1.2 (((Dialog)aWindow).getOwner()).getLocation();

                   Dimension parentSize = (((Dialog)aWindow).getParent()).getSize();

 //1.2                  Dimension parentSize = (((Dialog)aWindow).getOwner()).getSize();

                   if (parentSize.width > mySize.width)

                   {

                     x = ((parentSize.width - mySize.width)/2) + parentLocation.x;

                   }

                   if (parentSize.height > mySize.height)

                   {

                     y = ((parentSize.height - mySize.height)/2) + parentLocation.y;

                   }

                   break;

           case CENTER:

                   if (screenSize.width > mySize.width)

                   {

                     x = (screenSize.width - mySize.width)/2;

                   }

                   if (screenSize.height > mySize.height)

                   {

                     y = (screenSize.height - mySize.height)/2;

                   }

                   break;

           case CASCADE:

                   x = lastX + incrementX;

                   if ( x + mySize.width > screenSize.width )

                   {

                     x = incrementX;

                   }

                   y = lastY + incrementY;

                   if ( y + mySize.height > screenSize.height )

                   {

                     y = incrementY;

                   }

                   lastX = x;

                   lastY = y;

                   break;

           default:

                   // don't move the frame

                   Point p = aWindow.getLocation();

                   x = p.x;

                   y = p.y;

                   break;

         }

         aWindow.setLocation(x,y);

     }

 /**

  * Returns the first parent Window of the specified component.

  *

  * @param c the Component whose parent will be found.

  * @return the Window that contains the component,

  * or null if the component does not have a valid Frame parent.

  */

     public static Window getWindowForComponent(Component c)

     {

         for(Component p = c; p != null; p = p.getParent()) {

             if (p instanceof Window) {

                 return (Window) p;

             }

         }

         return null;

     }

 /**

 * Prints out a list of all components to System.out.

 * @param aContainer the Container whose components will be listed.

 */

     public static void dumpComponents( Container aContainer )

     {

         dumpComponents( aContainer, "" );

     }

     protected static void dumpComponents( Container aContainer, String padding )

     {

         Component c = null;

         int count = aContainer.getComponentCount();

         for ( int i = 0; i < count; i++ )

         {

             c = aContainer.getComponent( i );

             if ( c instanceof javax.swing.JComponent )

             {

                 System.out.println( padding + c.getClass() + ": "

                     + ((javax.swing.JComponent)c).getAccessibleContext().getAccessibleName() );

             }

             else

             {

                 System.out.println( padding + c.getClass() + ": " + c.getName() );

             }

             if ( c instanceof Container )

             {

                 dumpComponents( (Container) c, padding + "     " );

             }

         }

     }

 /**

 * Gets a list of all children of a specified container, sorted by position.

 * Components are sorted from top to bottom and then left to right.

 * @param aContainer The container whose children are to be returned.

 * @result A List containing the sorted components.

 */

     public static List getSortedChildComponents( Container aContainer )

     {

         List result = new ArrayList( getAllChildComponents( aContainer ) );

         Collections.sort( result, new PositionComparator( aContainer ) );

         return result;

     }

     public static void dumpSortedChildComponents( Container aContainer )

     {

         Component c = null;

         Iterator it = getSortedChildComponents( aContainer ).iterator();

         while ( it.hasNext() )

         {

             c = (Component) it.next();

             System.out.println( c.getLocation() + " : " + c.getClass()  );

         }

     }

     public static void dumpNamedChildComponents( Container aContainer )

     {

         Iterator it = getUniqueNameMap( getSortedChildComponents( aContainer ) ).values().iterator();

         while ( it.hasNext() )

         {

             System.out.println( it.next() );

         }

     }

 /**

 * Generates a unique name for each object in a list and returns

 * a map that maps the objects to the names.  The name is based

 * on the class of the object in the object list.

 * @param anObjectList A List of objects.

 * @return A Map that maps the objects in the list to the generated names.

 */

     public static Map getUniqueNameMap( List anObjectList )

     {

         Map namesToObjects = new HashMap(anObjectList.size(), 1F);

         Map objectsToNames = new HashMap(anObjectList.size(), 1F);

         Object o = null;

         String name = null;

         int lastIndex = 0;

         Iterator it = anObjectList.iterator();

         while ( it.hasNext() )

         {

             o = it.next();

             name = o.getClass().getName();

             lastIndex = name.lastIndexOf( "." );

             if ( lastIndex != -1 )

             {

                 name = name.substring( lastIndex+1 );

             }

             name = incrementString( name );

             while ( namesToObjects.get( name ) != null )

             {

                 name = incrementString( name );

             }

             namesToObjects.put( name, o );

             objectsToNames.put( o, name );

         }

         return objectsToNames;

     }

 /**

 * Numerically increments a string.  For example, "hello" becomes "hello1"

 * and "hello1" becomes "hello2" while "hello999" becomes "hello1000".

 * @param aString a String to be incremented.

 * @return The incremented String.

 */

     public static String incrementString( String aString )

     {

         int i = aString.length()-1;

         while ( ( i >= 0 ) && ( Character.isDigit( aString.charAt( i ) ) ) )

         {

             i--;

         }

         if ( i == aString.length()-1 )

         { // no numerics at end of string, increment manually

             return aString + "1";

         }

         String alpha = aString.substring( 0, i+1 );

         String numeric = aString.substring( i+1 );

         numeric = Integer.toString( Integer.parseInt( numeric ) + 1 );

         return alpha + numeric;

     }

 /**

 * Gets all children of the specified container.

 * @param aContainer the Container to be searched.

 * @return A Collection containing all of the child components of the container.

 */

     public static Collection getAllChildComponents( Container aContainer )

     {

         Collection result = new ArrayList();

         addAllChildComponents( aContainer, result );

         return result;

     }

 /**

 * Adds all children of the specified container to the specified collection.

 * @param aContainer the Container to be searched.

 * @param aCollection the Collection to which the child components will be added.

 */

     protected static void addAllChildComponents( Container aContainer, Collection aCollection )

     {

         Component c = null;

         int count = aContainer.getComponentCount();

         for ( int i = 0; i < count; i++ )

         {

             c = aContainer.getComponent( i );

             aCollection.add( c );

             if ( c instanceof Container )

             {

                 addAllChildComponents( (Container) c, aCollection );

             }

         }

     }

 /**

 * Sets each child component's tooltip to show the name generated from

 * getComponentNameMap(). 

 * (We're doing this so the tooltip authors can know how to reference

 * the components.)

 * @param aContainer the Container whose components will be labeled.

 */

     public static void labelComponents( Container aContainer )

     {

         Map nameToComponent = getNameToComponentMap( aContainer );

         Map nameToName = new HashMap(nameToComponent.size(), 1F);

         Iterator it = nameToComponent.keySet().iterator();

         String key;

         while ( it.hasNext() )

         {

             key = it.next().toString();

             nameToName.put( key, key );

         }

         labelComponents( aContainer, nameToName );

     }

 /**

 * Sets each child component's tooltip to show a given string retrieved

 * from a map using the component's generated name as a key.

 * @param aContainer the Container whose components will be labeled.

 * @param aNameMap a Map of generated names to string values.

 */

     public static void labelComponents( Container aContainer, Map aNameMap )

     {

         if ( aNameMap == null ) return;

         String key;

         Object o ;

         Iterator it = aNameMap.keySet().iterator();

         Map nameToComponent = getNameToComponentMap( aContainer );

         while ( it.hasNext() )

         {

             key = it.next().toString();

             o = nameToComponent.get( key );

             if ( o instanceof javax.swing.JComponent )

             {

                 ((javax.swing.JComponent)o).setToolTipText( aNameMap.get( key ).toString() );

             }

         }

     }

 /**

 * Generates a deterministically unique name for each component in a

 * container.  The name is based on the name of the class of the component

 * followed by a number.  Each class of component is numbered based on it's

 * position in the container, sorted from top to bottom and left to right.

 * @param aContainer the Container whose components will named.

 * @return a Map that maps each component to its name.

 */

     public static Map getComponentToNameMap( Container aContainer )

     {

         return getUniqueNameMap( getSortedChildComponents( aContainer ) );

     }

 /**

 * Maps a deterministically unique name to a component in a

 * container.  The name is based on the name of the class of the component

 * followed by a number.  Each class of component is numbered based on it's

 * position in the container, sorted from top to bottom and left to right.

 * @param aContainer the Container whose components will named.

 * @return a Map that maps each component to its name.

 */

     public static Map getNameToComponentMap( Container aContainer )

     {

         Map componentToName = getComponentToNameMap( aContainer );

         Map result = new HashMap(componentToName.size(), 1F);

         Iterator it = componentToName.keySet().iterator();

         Object key;

         while ( it.hasNext() )

         {

             key = it.next();

             result.put( componentToName.get( key ), key );

         }

         return result;

     }

 /**

 * Sets the tooltips of all components in a container to the

 * respective names of those components.  (We're using this

 * so the tooltip authors can know how to reference the components.)

 * @param aContainer the Container whose components will be labeled.

 */

     public static void nameComponents( Container aContainer )

     {

         nameComponents( aContainer, "" );

     }

     protected static void nameComponents( Container aContainer, String path )

     {

         Component c = null;

         String className = null;

         int index = 0;

         int count = aContainer.getComponentCount();

         for ( int i = 0; i < count; i++ )

         {

             c = aContainer.getComponent( i );

             className = c.getClass().getName();

             className = className.substring( className.lastIndexOf( '.' ) + 1 );

             System.out.println( path + className );

             if ( c instanceof javax.swing.JComponent )

             {

                 // ((javax.swing.JComponent)c).setToolTipText( path + className + " (" + c.getName() + ")" );

                 ((javax.swing.JComponent)c).setToolTipText( c.getName() );

             }

             if ( c instanceof Container )

             {

                 nameComponents( (Container) c, path + className + "." );

             }

         }

     }

 /**

 * Sets the enabled state of a container and all of its components.

 * @param aContainer the Container whose components will be enabled.

 * @param isEnabled True if enabled, false id disabled.

 */

     public static void enableComponents( Container aContainer, boolean isEnabled )

     {

         Component c = null;

         String className = null;

         int index = 0;

         int count = aContainer.getComponentCount();

         for ( int i = 0; i < count; i++ )

         {

             c = aContainer.getComponent( i );

             if ( c instanceof Container )

             {

                 enableComponents( (Container) c, isEnabled );

             }

             else

             {

                 c.setEnabled( isEnabled );

             }

         }

         aContainer.setEnabled( isEnabled );

     }

 }

 /*

  * $Log$

  * Revision 1.2  2006/02/18 23:19:05  cgruber

  * Update imports and maven dependencies.

  *

  * Revision 1.1  2006/02/16 13:22:22  cgruber

  * Check in all sources in eclipse-friendly maven-enabled packages.

  *

  * Revision 1.2  2001/02/17 16:52:05  mpowers

  * Changes in imports to support building with jdk1.1 collections.

  *

  * Revision 1.1.1.1  2000/12/21 15:51:55  mpowers

  * Contributing wotonomy.

  *

  * Revision 1.2  2000/12/20 16:25:46  michael

  * Added log to all files.

  *

  *

  */