AWT Utilities : GUI Utilities « Swing JFC « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » Swing JFC » GUI UtilitiesScreenshots 
AWT Utilities
   

/**
 * The utillib library.
 * More information is available at http://www.jinchess.com/.
 * Copyright (C) 2002, 2003 Alexander Maryanovsky.
 * All rights reserved.
 *
 * The utillib 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 of the
 * License, or (at your option) any later version.
 *
 * The utillib 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 utillib library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */



import java.awt.*;
import java.lang.reflect.*;


/**
 * A collection of AWT related utilities.
 */

public class AWTUtilities{



  /**
   * Packs and centers the given window relative to the given component. The
   * specified component may be <code>null</code>, in which case the window will
   * be centered on the screen. The method also makes sure that the target
   * window is fully visible by calling <code>forceToScreen</code>.
   */

  public static void centerWindow(Window target, Component parent){
    target.pack();

    Dimension size = target.getSize();
    Rectangle parentBounds = parent == null || !parent.isShowing() 
      getUsableScreenBounds() :
      new Rectangle(parent.getLocationOnScreen(), parent.getSize());

    target.setLocation(parentBounds.x + (parentBounds.width - size.width)/2, parentBounds.y + (parentBounds.height - size.height)/2);
    
    forceToScreen(target);
  }
  
  
  
  /**
   * Reposition the specified window so that it necessarily fits on the screen,
   * while trying to minimize changes.
   */
   
  public static void forceToScreen(Window window){
    Dimension screenSize = window.getToolkit().getScreenSize();
    Rectangle bounds = window.getBounds();
    
    bounds.width = Math.min(bounds.width, screenSize.width);
    bounds.height = Math.min(bounds.height, screenSize.height);
    bounds.x = Math.min(Math.max(bounds.x, 0), screenSize.width - bounds.width);    
    bounds.y = Math.min(Math.max(bounds.y, 0), screenSize.height - bounds.height);

    window.setBounds(bounds);    
  }




  /**
   * Returns the parent Frame of the specified <code>Component</code> or
   * <code>null</code> if none exists.
   */

  public static Frame frameForComponent(Component component){
    while (component != null){
      if (component instanceof Frame)
        return (Frame)component;
      component = component.getParent();
    }

    return null;
  }




  /**
   * Returns a list of available font names. Under JDK1.1 it uses
   * <code>Toolkit.getFontList()</code> while under JDK1.2 (via reflection),
   * <code>GraphicsEnvironment.getAvailableFontFamilyNames()</code>
   */

  public static String [] getAvailableFontNames(){
    if (PlatformUtils.isJavaBetterThan("1.2")){
      try{
        // The equivalent of "return GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();"
        Class geClass = Class.forName("java.awt.GraphicsEnvironment");
        Method getLocalGraphicsEnvironmentMethod = geClass.getMethod("getLocalGraphicsEnvironment"new Class[0]);
        Object localGE = getLocalGraphicsEnvironmentMethod.invoke(null, new Object[0]);
        Method getAvailableFontFamilyNamesMethod = geClass.getMethod("getAvailableFontFamilyNames"new Class[0]);
        String [] fontNames = (String [])getAvailableFontFamilyNamesMethod.invoke(localGE, new Object[0]);
        return fontNames;
      catch (ClassNotFoundException e){e.printStackTrace();}
        catch (NoSuchMethodException e){e.printStackTrace();}
        catch (IllegalAccessException e){e.printStackTrace();}
        catch (InvocationTargetException e){e.printStackTrace();}
      return null;
    }
    else
      return Toolkit.getDefaultToolkit().getFontList();
  }
  
  
  
  /**
   * Returns the state of the specified frame, as specified by
   * <code>Frame.getExtendedState()</code> if running under JDK 1.4 or later,
   * otherwise returns 0. The call to <code>Frame.getExtendedState()</code> is
   * done via reflection to avoid runtime errors.
   */
   
  public static int getExtendedFrameState(Frame frame){
    if (PlatformUtils.isJavaBetterThan("1.4")){
      try{
        Class frameClass = Class.forName("java.awt.Frame");
        Method getExtendedStateMethod = frameClass.getMethod("getExtendedState"new Class[0]);
        Integer state = (Integer)getExtendedStateMethod.invoke(frame, new Object[0]);
        return state.intValue();
      catch (ClassNotFoundException e){e.printStackTrace();}
        catch (NoSuchMethodException e){e.printStackTrace();}
        catch (IllegalAccessException e){e.printStackTrace();}
        catch (InvocationTargetException e){e.printStackTrace();}
    }
    
    return 0;
  }
  
  
  
  /**
   * Sets the state of the specified frame, as specified by
   * <code>Frame.setExtendedState</code> if running in JDK 1.4 or later,
   * otherwise does nothing. The call to <code>Frame.setExtendedState()</code>
   * is done via reflection to avoid runtime errors. 
   */
   
  public static void setExtendedFrameState(Frame frame, int state){
    if (PlatformUtils.isJavaBetterThan("1.4")){
      try{
        Class frameClass = Class.forName("java.awt.Frame");
        Method setExtendedStateMethod = frameClass.getMethod("setExtendedState"new Class[]{int.class});
        setExtendedStateMethod.invoke(frame, new Object[]{new Integer(state)});
      catch (ClassNotFoundException e){e.printStackTrace();}
        catch (NoSuchMethodException e){e.printStackTrace();}
        catch (IllegalAccessException e){e.printStackTrace();}
        catch (InvocationTargetException e){e.printStackTrace();}
    }
  }
  
  
  
  /**
   * Attempts to determine the usable screen bounds of the default screen
   * device. If the require java.awt API is not available under the JVM we're
   * running in, this will simply return the screen bounds obtained via
   * <code>Toolkit.getScreenSize()</code>.
   */
  
  public static Rectangle getUsableScreenBounds(){
    if (PlatformUtils.isJavaBetterThan("1.4")){
      try{
        Class graphicsEnvironmentClass = Class.forName("java.awt.GraphicsEnvironment");
        Class graphicsDeviceClass = Class.forName("java.awt.GraphicsDevice");
        Class graphicsConfigurationClass = Class.forName("java.awt.GraphicsConfiguration");
        
        Class [] emptyClassArr = new Class[0];
        Method getLocalGraphicsEnvironmentMethod = 
          graphicsEnvironmentClass.getMethod("getLocalGraphicsEnvironment", emptyClassArr);
        Method getDefaultScreenDeviceMethod = 
          graphicsEnvironmentClass.getMethod("getDefaultScreenDevice", emptyClassArr);
        Method getDefaultConfigurationMethod =
          graphicsDeviceClass.getMethod("getDefaultConfiguration", emptyClassArr);
        Method getBoundsMethod = 
          graphicsConfigurationClass.getMethod("getBounds", emptyClassArr);
        Method getScreenInsetsMethod = 
          Toolkit.class.getMethod("getScreenInsets"new Class[]{graphicsConfigurationClass});
        
        Object [] emptyObjArr = new Object[0];
        Object graphicsEnvironment = getLocalGraphicsEnvironmentMethod.invoke(null, emptyObjArr);
        Object defaultScreenDevice = getDefaultScreenDeviceMethod.invoke(graphicsEnvironment, emptyObjArr);
        Object defaultConfiguration = getDefaultConfigurationMethod.invoke(defaultScreenDevice, emptyObjArr);
        Rectangle bounds = (Rectangle)getBoundsMethod.invoke(defaultConfiguration, emptyObjArr);
        Insets insets = 
          (Insets)getScreenInsetsMethod.invoke(Toolkit.getDefaultToolkit()new Object[]{defaultConfiguration});
        
        bounds.x += insets.left;
        bounds.y += insets.top;
        bounds.width -= insets.left + insets.right;
        bounds.height -= insets.top + insets.bottom;
        
        return bounds;
      catch (ClassNotFoundException e){e.printStackTrace();}
        catch (SecurityException e){e.printStackTrace();}
        catch (NoSuchMethodException e){e.printStackTrace();}
        catch (IllegalArgumentException e){e.printStackTrace();}
        catch (IllegalAccessException e){e.printStackTrace();}
        catch (InvocationTargetException e){e.printStackTrace();}
    }

    return new Rectangle(new Point(00), Toolkit.getDefaultToolkit().getScreenSize());
  }
  
  
  
  
  /**
   * Enables or disables all the components within the specified container.
   
   * This is a rather hacky method - it doesn't work well if there are both
   * enabled and disabled components in the container.
   */

  public static void setContainerEnabled(Container container, boolean enabled){
    Component [] children = container.getComponents();
    for (int i = 0; i < children.length; i++){
      Component child = children[i];
      child.setEnabled(enabled);
      if (child instanceof Container)
        setContainerEnabled((Container)child, enabled);
    }
  }
  


}
/**
 * The utillib library.
 * More information is available at http://www.jinchess.com/.
 * Copyright (C) 2004 Alexander Maryanovsky.
 * All rights reserved.
 *
 * The utillib 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 of the
 * License, or (at your option) any later version.
 *
 * The utillib 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 utillib library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 


/**
 * A class which contains various platform specific utilities.
 */
 
 class PlatformUtils{
  
  
  
  /**
   * Returns whether the version of Java we're running in is higher than or
   * equal to the specified version.
   */
   
  public static boolean isJavaBetterThan(String ver){
    return System.getProperty("java.version").compareTo(ver>= 0;
  }
  
  
  
  /**
   * Returns whether we're running under the old (just in case there's ever a
   * new one) Microsoft VM.
   */
   
  public static boolean isOldMicrosoftVM(){
    String vendor = System.getProperty("java.vendor");

    return (vendor != null&& vendor.toLowerCase().startsWith("microsoft"&& 
           !isJavaBetterThan("1.2");    
  }
  
  
  
  /**
   * Returns whether we're running under Windows.
   */
   
  public static boolean isWindows(){
    String os = System.getProperty("os.name")

    return (os != null&& os.toLowerCase().startsWith("windows");
  }
  
  
  
  /**
   * Returns whether we're running under Windows 95/98/ME.
   */
   
  public static boolean isOldWindows(){
    String os = System.getProperty("os.name");
    
    return isWindows() && (System.getProperty("os.version").compareTo("5.0"0&&
                          !os.toLowerCase().startsWith("windows nt");
  }
  
  
  
  /**
   * Returns whether we're running under Linux.
   */
   
  public static boolean isLinux(){
    String os = System.getProperty("os.name")

    return (os != null&& os.toLowerCase().startsWith("linux");
  }
  
  
  
  /**
   * Returns whether we're running under Mac OS.
   */
   
  public static boolean isMacOS(){
    String os = System.getProperty("os.name");

    return (os != null&& os.toLowerCase().startsWith("mac");
  }
  
  
  
  /**
   * Returns whether we're running under Mac OS X.
   */
   
  public static boolean isMacOSX(){
    String os = System.getProperty("os.name");

    return (os != null&& os.toLowerCase().startsWith("mac os x");
  }
  
  
  
  /**
   * Returns whether we're running under Solaris.
   */
   
  public static boolean isSolaris(){
    String os = System.getProperty("os.name");
    
    return (os != null&& (os.toLowerCase().startsWith("solaris"||
                            os.toLowerCase().startsWith("sunos"));
  }
  
  
  
  /**
   * Returns the name of the OS we're running on, out of the specified list:
   * <ul>
   *   <li>windows
   *   <li>linux
   *   <li>macosx
   *   <li>solaris
   * </ul>
   
   * Returns <code>null</code> if we're running on an OS which is not in the
   * above list.
   */
  
  public static String getOSName(){
    if (isWindows() || isOldWindows())
      return "windows";
    else if (isLinux())
      return "linux";
    else if (isMacOSX())
      return "macosx";
    else if (isSolaris())
      return "solaris";
    else
      return null;
  }
  
  
   
}

   
    
    
  
Related examples in the same category
1.Utilities for GUI work.
2.A utility class to tune the Metal look and feel.
3.Renders a component into an image
4.Positions the specified dialog at a position relative to its parent.
5.Computes the maximum bounds of the current screen device. If this method is called on JDK 1.4, Xinerama-aware results are returned.
6.Computes the center point of the current screen device.
7.Positions the specified frame at a relative position in the screen, where 50% is considered to be the center of the screen.
8.Positions the specified frame in the middle of the screen.
9.Positions the specified frame at a random location on the screen while ensuring that the
10.Center On Screen
11.Center Within Parent
12.Center window
13.Calculates preferred max height for the given components without checking isVisible
14.Calculates preferred max width for the given components without checking isVisible
15.Is Focusable
16.Loading the given image
17.Press a key pragmatically
18.Set All Opaque
19.Set Frame Location Relative To
20.Set Wait Cursor
21.Shadow Popup Border
22.Unit conversions
23.Unit measure
24.Get Point For Centering
25.Get Point For Staggering
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.