[kaffe] Classpath AWT progress.
James Simmons
jsimmons at infradead.org
Mon Dec 8 11:27:02 PST 2003
> James Simmons <jsimmons at infradead.org> writes:
>
> > Give me a few days to get a patch going. At present I'm working on
> > code that hits two targets, X windows and the linux framebuffer
> > console. I want to get a system going that runs on X windows and the
> > framebuffer console at the same time!!!
>
> Can we call you Santa Claus?
Here is the code I have so far. I extended GraphicsEnvironment to actually
work. At present it gives exceptions. The main file is
ClasspathGraphicsEnvironment.java. Its goal is to load each type of
GraphicsDevice driver. I have fbinput and xlib drivers of which I attached
XGraphicsDevice. What I'm attempting to tackle now is loading more than
one object for each type of driver. I haven't got it to work just yet.
Improvements and comments welcomed.
/* ClasspathGraphicsEnvironment.java -- information about the graphics environment
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath 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 2, or (at your option)
any later version.
GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.awt;
import gnu.classpath.Configuration;
import java.awt.HeadlessException;
import java.awt.image.BufferedImage;
import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Point;
import java.awt.Font;
import java.util.Locale;
/**
* This descibes the collection of GraphicsDevice and Font objects available
* on a given platform. The resources might be local or remote, and specify
* the valid configurations for displaying graphics.
*
* @author James Simmons <jsimmons at infradead.org>
* @see GraphicsDevice
* @see GraphicsConfiguration
* @since 1.4
* @status updated to 1.4
*/
public class ClasspathGraphicsEnvironment extends GraphicsEnvironment
{
String [] drivers = { "gnu.java.awt.peer.xlib.XGraphicsDevice" ,
"gnu.java.awt.peer.fbinput.FBGraphicsDevice" };
GraphicsDevice [] displays = new GraphicsDevice [drivers.length];
GraphicsDevice firstpick;
boolean unplugged = true;
static
{
if (Configuration.INIT_LOAD_LIBRARY)
System.loadLibrary("awt");
}
/**
* The environment must be obtained from a factory or query method, hence
* this constructor is protected.
*
* At present we only work with a local X Windows connection. In the future
* we could expand this to include remote connections. To do that I have to
* do two things. First pass in the hostname of the machines I want to
* connect to. Second tell the difference between the local connection and
* the remote.
*/
protected ClasspathGraphicsEnvironment()
{
int count = 0, i = 0;
while (i < drivers.length) {
try {
Class cls = Class.forName(drivers[i]);
while (true) {
Object obj = cls.newInstance();
if (obj instanceof GraphicsDevice) {
displays[count++] = (GraphicsDevice) obj;
} else {
break;
}
}
} catch (Throwable t) {
System.err.println("Driver "+drivers[i]+" not avaliable");
}
i++;
}
if (count == 0) {
throw new HeadlessException("No Displays avaliable");
} else
firstpick = displays[0];
}
/**
* Get an array of all the GraphicsDevice objects.
*
* @return the available graphics devices, may be 0 length
* @throws HeadlessException if the environment is headless
*/
public GraphicsDevice[] getScreenDevices()
{
return displays;
}
/**
* Get the default screen GraphicsDevice object.
*
* @return the default screen device
* @throws HeadlessException if the environment is headless
*/
public GraphicsDevice getDefaultScreenDevice()
{
return firstpick;
}
/**
* Return a Graphics2D object which will render into the specified image.
*
* @param image the image to render into
* @return the object that renders into the image
*/
public Graphics2D createGraphics(BufferedImage image)
{
return null;
}
/**
* Returns an array of the one-point size fonts available in this
* environment. From there, the user can select the font and derive the
* correct one of proper size and attributes, using <code>deriveFont</code>.
* Only one master version of each font appears in this array; if a font
* can be derived from another, it must be created in that way.
*
* @return the array of available fonts
* @see #getAvailableFontFamilyNames()
* @see Font#deriveFont(int, float)
* @since 1.2
*/
public Font[] getAllFonts()
{
return null;
}
/**
* Returns an array of the font family names available in this environment.
* This allows flexibility in choosing the style of font, while still letting
* the Font class decide its best match.
*
* @return the array of available font families
* @see #getAllFonts()
* @see Font#getFamily()
* @since 1.2
*/
public String[] getAvailableFontFamilyNames()
{
return null;
}
/**
* Returns an array of the font family names available in this environment,
* localized to the current Locale if l is non-null. This allows
* flexibility in choosing the style of font, while still letting the Font
* class decide its best match.
*
* @param l the locale to use
* @return the array of available font families, localized
* @see #getAllFonts()
* @see Font#getFamily()
* @since 1.2
*/
public String[] getAvailableFontFamilyNames(Locale l)
{
return null;
}
/**
* Returns the point where a window should be centered. You should probably
* also check that the window fits within the screen bounds. The default
* simply returns the center of the maximum window bounds; subclasses should
* override this if native objects (like scrollbars) make that off-centered.
*
* @return the centering point
* @throws HeadlessException if the environment is headless
* @see #getMaximumWindowBounds()
* @since 1.4
*/
public Point getCenterPoint()
{
Rectangle r = getMaximumWindowBounds();
return new Point(r.x + r.width / 2, r.y + r.height / 2);
}
/**
* Returns the maximum bounds for a centered window object. The default
* implementation simply returns the bounds of the default configuration
* of the default screen; subclasses should override this to if native
* objects (like scrollbars) reduce what is truly available. Also,
* subclasses should override this if the window should be centered across
* a multi-screen display.
*
* @return the maximum window bounds
* @throws HeadlessException if the environment is headless
* @see #getCenterPoint()
* @see GraphicsConfiguration#getBounds()
* @see Toolkit#getScreenInsets(GraphicsConfiguration)
* @since 1.4
*/
public Rectangle getMaximumWindowBounds()
{
return getDefaultScreenDevice().getDefaultConfiguration().getBounds();
}
} // class ClasspathGraphicsEnvironment
-------------- next part --------------
/* XGraphicsDevice.java -- information about a graphics device
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath 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 2, or (at your option)
any later version.
GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.awt.peer.xlib;
import java.awt.GraphicsConfigTemplate;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.DisplayMode;
import java.awt.Window;
/**
* This describes a graphics device available to the given environment. This
* includes screen and printer devices, and the different configurations for
* each device. Also, this allows you to create virtual devices which operate
* over a multi-screen environment.
*
* @author Eric Blake <ebb9 at email.byu.edu>
* @see GraphicsEnvironment
* @see GraphicsConfiguration
* @since 1.3
* @status updated to 1.4
*/
public class XGraphicsDevice extends GraphicsDevice
{
/** Device is a raster screen. */
public static final int TYPE_RASTER_SCREEN = 0;
/** Device is a printer. */
public static final int TYPE_PRINTER = 1;
/** Device is an image buffer not visible to the user. */
public static final int TYPE_IMAGE_BUFFER = 2;
/** The current full-screen window, or null if there is none. */
private Window full_screen;
/** The current display mode, or null if unknown. */
private DisplayMode mode;
/** All the display modes supported. */
private DisplayMode [] modes;
/** Name of the Display. */
private String name;
/** Type of Display. */
private int type;
/** Number of screens. */
static private int count = 5;
/**
* The default constructor.
*
* @see GraphicsEnvironment#getScreenDevices()
* @see GraphicsEnvironment#getDefaultScreenDevice()
* @see GraphicsConfiguration#getDevice()
*/
protected XGraphicsDevice()
{
System.err.println("count is "+count);
count--;
}
/**
* Returns the type of the device.
*
* @return the device type
* @see #TYPE_RASTER_SCREEN
* @see #TYPE_PRINTER
* @see #TYPE_IMAGE_BUFFER
*/
public int getType()
{
return type;
}
/**
* Returns an identification string for the device. This can be
* vendor-specific, and may be useful for debugging.
*
* @return the identification
*/
public String getIDstring()
{
return name;
}
/**
* Return all configurations valid for this device.
*
* @return an array of configurations
*/
public GraphicsConfiguration[] getConfigurations()
{
return null;
}
/**
* Return the default configuration for this device.
*
* @return the default configuration
*/
public GraphicsConfiguration getDefaultConfiguration()
{
return null;
}
/**
* Return the best configuration, according to the criteria in the given
* template.
*
* @param template the template to adjust by
* @return the best configuration
* @throws NullPointerException if template is null
*/
public GraphicsConfiguration getBestConfiguration
(GraphicsConfigTemplate template)
{
return template.getBestConfiguration(getConfigurations());
}
/**
* Returns true if the device supports full-screen exclusive mode. The
* default implementation returns true; subclass it if this is not the case.
*
* @return true if full screen support is available
* @since 1.4
*/
public boolean isFullScreenSupported()
{
return true;
}
/**
* Toggle the given window between full screen and normal mode. The previous
* full-screen window, if different, is restored; if the given window is
* null, no window will be full screen. If
* <code>isFullScreenSupported()</code> returns true, full screen mode is
* considered to be exclusive, which implies:<ul>
* <li>Windows cannot overlap the full-screen window. All other application
* windows will always appear beneath the full-screen window in the
* Z-order.</li>
* <li>Input method windows are disabled. It is advisable to call
* <code>Component.enableInputMethods(false)</code> to make a component
* a non-client of the input method framework.</li>
* </ul><br>
* If <code>isFullScreenSupported()</code> returns false, full-screen
* exclusive mode is simulated by resizing the window to the size of the
* screen and positioning it at (0,0).
*
* XXX Not yet implemented in Classpath.
*
* @param w the window to toggle
* @see #isFullScreenSupported()
* @see getFullScreenWindow()
* @see setDisplayMode(DisplayMode)
* @see Component#enableInputMethods(boolean)
* @since 1.4
*/
public synchronized void setFullScreenWindow(Window w)
{
if (full_screen != null)
; // XXX Restore the previous window to normal mode.
full_screen = w;
// XXX If w != null, make it full-screen.
throw new Error("not implemented");
}
/**
* Returns the current full-screen window of the device, or null if no
* window is full-screen.
*
* @return the full-screen window
* @see #setFullScreenWindow(Window)
* @since 1.4
*/
public Window getFullScreenWindow()
{
return full_screen;
}
/**
* Returns whether this device supports low-level display changes. This may
* depend on whether full-screen exclusive mode is available.
*
* XXX The default implementation returns false for now.
*
* @return true if display changes are supported
* @see #setDisplayMode(DisplayMode)
* @since 1.4
*/
public boolean isDisplayChangeSupported()
{
return false;
}
/**
* Sets the display mode. This may be dependent on the availability of
* full-screen exclusive mode.
*
* @param mode the new mode
* @throws IllegalArgumentException if the new mode is not in getDisplayModes
* @throws UnsupportedOperationException if ! isDisplayChangeSupported()
* @see #getDisplayMode()
* @see #getDisplayModes()
* @see #isDisplayChangeSupported()
* @since 1.4
*/
public void setDisplayMode(DisplayMode mode)
{
DisplayMode[] array = getDisplayModes();
if (! isDisplayChangeSupported())
throw new UnsupportedOperationException();
int i = array == null ? 0 : array.length;
while (--i >= 0)
if (array[i].equals(mode))
break;
if (i < 0)
throw new IllegalArgumentException();
this.mode = mode;
}
/**
* Returns the current display mode of this device, or null if unknown.
*
* @return the current display mode
* @see #setDisplayMode(DisplayMode)
* @see #getDisplayModes()
* @since 1.4
*/
public DisplayMode getDisplayMode()
{
return mode;
}
/**
* Return an array of all available display modes. This implementation
* returns a 0-length array, so subclasses must override this.
*
* @return the array of available modes
* @since 1.4
*/
public DisplayMode[] getDisplayModes()
{
return modes;
}
/**
* Return the number of bytes available in accelerated memory on this
* device. The device may support creation or caching on a first-come,
* first-served basis, depending on the operating system and driver.
* Memory may be a finite resource, and because of multi-threading, you
* are not guaranteed that the result of this method ensures your image
* will successfully be put in accelerated memory. A negative result means
* the memory is unlimited. The default implementation assumes no special
* memory is available, and returns 0.
*
* @return the size of accelerated memory available
* @see VolatileImage#flush()
* @see ImageCapabilities#isAccelerated()
*/
public int getAvailableAcceleratedMemory()
{
return 0;
}
} // class GraphicsDevice
-------------- next part --------------
/* GraphicsEnvironment.java -- information about the graphics environment
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath 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 2, or (at your option)
any later version.
GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.awt;
import java.awt.image.BufferedImage;
import java.util.Locale;
/**
* This descibes the collection of GraphicsDevice and Font objects available
* on a given platform. The resources might be local or remote, and specify
* the valid configurations for displaying graphics.
*
* @author Eric Blake <ebb9 at email.byu.edu>
* @see GraphicsDevice
* @see GraphicsConfiguration
* @since 1.4
* @status updated to 1.4
*/
public abstract class GraphicsEnvironment
{
/**
* The default graphics system.
*/
private static String default_name =
"gnu.java.awt.peer.xlib.XGraphicsEnvironment";
/**
* Test to see if we are in a graphical environment.
*/
private boolean unplugged;
/**
* The actual Graphics environments.
*/
private static GraphicsEnvironment env;
/**
* The environment must be obtained from a factory or query method, hence
* this constructor is protected.
*/
protected GraphicsEnvironment()
{
}
/**
* Returns the local graphics environment.
*
* XXX Not implemented in Classpath yet.
* @return the local environment
*/
public static GraphicsEnvironment getLocalGraphicsEnvironment()
{
if (env != null)
return env;
String environment_name =
"gnu.java.awt.ClasspathGraphicsEnvironment";
try {
Class cls = Class.forName(environment_name);
Object obj = cls.newInstance();
if (!(obj instanceof GraphicsEnvironment))
throw new HeadlessException(environment_name + " does not exist");
env = (GraphicsEnvironment) obj;
return env;
} catch (Throwable t) {
HeadlessException e = new HeadlessException("Can't load GraphicsEnvironment");
throw (HeadlessException) e.initCause(t);
}
}
/**
* Check if the local environment is headless, meaning that it does not
* support a display, keyboard, or mouse. Many methods in the Abstract
* Windows Toolkit (java.awt) throw a {@link HeadlessException} if this
* returns true.
*
* XXX For now, Classpath assumes that it is never headless.
*
* @return true if the environment is headless, meaning that graphics are
* unsupported
* @since 1.4
*/
public static boolean isHeadless()
{
return getLocalGraphicsEnvironment().isHeadlessInstance();
}
/**
* Check if the given environment is headless, meaning that it does not
* support a display, keyboard, or mouse. Many methods in the Abstract
* Windows Toolkit (java.awt) throw a {@link HeadlessException} if this
* returns true. This default implementation returns false, so subclasses
* need only override it if they are headless.
*
* @return true if the environment is headless, meaning that graphics are
* unsupported
* @since 1.4
*/
public boolean isHeadlessInstance()
{
return unplugged;
}
/**
* Get an array of all the GraphicsDevice objects.
*
* @return the available graphics devices, may be 0 length
* @throws HeadlessException if the environment is headless
*/
public abstract GraphicsDevice[] getScreenDevices();
/**
* Get the default screen GraphicsDevice object.
*
* @return the default screen device
* @throws HeadlessException if the environment is headless
*/
public abstract GraphicsDevice getDefaultScreenDevice();
/**
* Return a Graphics2D object which will render into the specified image.
*
* @param image the image to render into
* @return the object that renders into the image
*/
public abstract Graphics2D createGraphics(BufferedImage image);
/**
* Returns an array of the one-point size fonts available in this
* environment. From there, the user can select the font and derive the
* correct one of proper size and attributes, using <code>deriveFont</code>.
* Only one master version of each font appears in this array; if a font
* can be derived from another, it must be created in that way.
*
* @return the array of available fonts
* @see #getAvailableFontFamilyNames()
* @see Font#deriveFont(int, float)
* @since 1.2
*/
public abstract Font[] getAllFonts();
/**
* Returns an array of the font family names available in this environment.
* This allows flexibility in choosing the style of font, while still letting
* the Font class decide its best match.
*
* @return the array of available font families
* @see #getAllFonts()
* @see Font#getFamily()
* @since 1.2
*/
public abstract String[] getAvailableFontFamilyNames();
/**
* Returns an array of the font family names available in this environment,
* localized to the current Locale if l is non-null. This allows
* flexibility in choosing the style of font, while still letting the Font
* class decide its best match.
*
* @param l the locale to use
* @return the array of available font families, localized
* @see #getAllFonts()
* @see Font#getFamily()
* @since 1.2
*/
public abstract String[] getAvailableFontFamilyNames(Locale l);
/**
* Returns the point where a window should be centered. You should probably
* also check that the window fits within the screen bounds. The default
* simply returns the center of the maximum window bounds; subclasses should
* override this if native objects (like scrollbars) make that off-centered.
*
* @return the centering point
* @throws HeadlessException if the environment is headless
* @see #getMaximumWindowBounds()
* @since 1.4
*/
public Point getCenterPoint()
{
Rectangle r = getMaximumWindowBounds();
return new Point(r.x + r.width / 2, r.y + r.height / 2);
}
/**
* Returns the maximum bounds for a centered window object. The default
* implementation simply returns the bounds of the default configuration
* of the default screen; subclasses should override this to if native
* objects (like scrollbars) reduce what is truly available. Also,
* subclasses should override this if the window should be centered across
* a multi-screen display.
*
* @return the maximum window bounds
* @throws HeadlessException if the environment is headless
* @see #getCenterPoint()
* @see GraphicsConfiguration#getBounds()
* @see Toolkit#getScreenInsets(GraphicsConfiguration)
* @since 1.4
*/
public Rectangle getMaximumWindowBounds()
{
return getDefaultScreenDevice().getDefaultConfiguration().getBounds();
}
} // class GraphicsEnvironment
More information about the kaffe
mailing list