|
/**
* 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(0, 0), 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;
}
}
|