/* Toolkit.java -- AWT Toolkit superclass
Copyright (C) 1999, 2000, 2001, 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.datatransfer.Clipboard;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DragGestureRecognizer;
import java.awt.dnd.DragSource;
import java.awt.dnd.peer.DragSourceContextPeer;
import java.awt.event.AWTEventListener;
import java.awt.event.KeyEvent;
import java.awt.im.InputMethodHighlight;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.peer.ButtonPeer;
import java.awt.peer.CanvasPeer;
import java.awt.peer.CheckboxPeer;
import java.awt.peer.CheckboxMenuItemPeer;
import java.awt.peer.ChoicePeer;
import java.awt.peer.DialogPeer;
import java.awt.peer.FileDialogPeer;
import java.awt.peer.FontPeer;
import java.awt.peer.FramePeer;
import java.awt.peer.LabelPeer;
import java.awt.peer.LightweightPeer;
import java.awt.peer.ListPeer;
import java.awt.peer.MenuPeer;
import java.awt.peer.MenuBarPeer;
import java.awt.peer.MenuItemPeer;
import java.awt.peer.PanelPeer;
import java.awt.peer.PopupMenuPeer;
import java.awt.peer.ScrollbarPeer;
import java.awt.peer.ScrollPanePeer;
import java.awt.peer.TextAreaPeer;
import java.awt.peer.TextFieldPeer;
import java.awt.peer.WindowPeer;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.net.URL;
import java.util.Map;
import java.util.Properties;
/**
* The AWT system uses a set of native peer objects to implement its
* widgets. These peers are provided by a peer toolkit, that is accessed
* via a subclass of this superclass. The system toolkit is retrieved
* by the static methods getDefaultToolkit
. This method
* determines the system toolkit by examining the system property
* awt.toolkit
. That property is set to the name of the
* Toolkit
subclass for the specified peer set. If the
* awt.toolkit
property is not set, then the default
* toolkit gnu.java.awt.peer.gtk.GtkToolkit
is used. This
* toolkit creates its peers using the GTK+ toolkit.
*
* @author Aaron M. Renn
*/
public abstract class Toolkit
{
/** The default toolkit name. */
private static String default_toolkit_name
= "gnu.java.awt.peer.gtk.GtkToolkit";
/**
* The toolkit in use. Once we load it, we don't ever change it
* if the awt.toolkit property is set.
*/
private static Toolkit toolkit;
/** The toolkit properties. */
private static Properties props = new Properties();
protected final Map desktopProperties = new Properties();
protected final PropertyChangeSupport desktopPropsSupport
= new PropertyChangeSupport(this);
/**
* Default constructor for subclasses.
*/
public Toolkit()
{
}
/**
* Creates a peer object for the specified Button
.
*
* @param target The Button
to create the peer for.
* @return The peer for the specified Button
object.
*/
protected abstract ButtonPeer createButton(Button target);
/**
* Creates a peer object for the specified TextField
.
*
* @param target The TextField
to create the peer for.
* @return The peer for the specified TextField
object.
*/
protected abstract TextFieldPeer createTextField(TextField target);
/**
* Creates a peer object for the specified Label
.
*
* @param target The Label
to create the peer for.
* @return The peer for the specified Label
object.
*/
protected abstract LabelPeer createLabel(Label target);
/**
* Creates a peer object for the specified List
.
*
* @param target The List
to create the peer for.
* @return The peer for the specified List
object.
*/
protected abstract ListPeer createList(List target);
/**
* Creates a peer object for the specified Checkbox
.
*
* @param target The Checkbox
to create the peer for.
* @return The peer for the specified Checkbox
object.
*/
protected abstract CheckboxPeer createCheckbox(Checkbox target);
/**
* Creates a peer object for the specified Scrollbar
.
*
* @param target The Scrollbar
to create the peer for.
* @return The peer for the specified Scrollbar
object.
*/
protected abstract ScrollbarPeer createScrollbar(Scrollbar target);
/**
* Creates a peer object for the specified ScrollPane
.
*
* @param target The ScrollPane
to create the peer for.
* @return The peer for the specified ScrollPane
object.
*/
protected abstract ScrollPanePeer createScrollPane(ScrollPane target);
/**
* Creates a peer object for the specified TextArea
.
*
* @param target The TextArea
to create the peer for.
* @return The peer for the specified TextArea
object.
*/
protected abstract TextAreaPeer createTextArea(TextArea target);
/**
* Creates a peer object for the specified Choice
.
*
* @param target The Choice
to create the peer for.
* @return The peer for the specified Choice
object.
*/
protected abstract ChoicePeer createChoice(Choice target);
/**
* Creates a peer object for the specified Frame
.
*
* @param target The Frame
to create the peer for.
* @return The peer for the specified Frame
object.
*/
protected abstract FramePeer createFrame(Frame target);
/**
* Creates a peer object for the specified Canvas
.
*
* @param target The Canvas
to create the peer for.
* @return The peer for the specified Canvas
object.
*/
protected abstract CanvasPeer createCanvas(Canvas target);
/**
* Creates a peer object for the specified Panel
.
*
* @param target The Panel
to create the peer for.
* @return The peer for the specified Panel
object.
*/
protected abstract PanelPeer createPanel(Panel target);
/**
* Creates a peer object for the specified Window
.
*
* @param target The Window
to create the peer for.
* @return The peer for the specified Window
object.
*/
protected abstract WindowPeer createWindow(Window target);
/**
* Creates a peer object for the specified Dialog
.
*
* @param target The dialog to create the peer for
* @return The peer for the specified font name.
*/
protected abstract DialogPeer createDialog(Dialog target);
/**
* Creates a peer object for the specified MenuBar
.
*
* @param target The MenuBar
to create the peer for.
* @return The peer for the specified MenuBar
object.
*/
protected abstract MenuBarPeer createMenuBar(MenuBar target);
/**
* Creates a peer object for the specified Menu
.
*
* @param target The Menu
to create the peer for.
* @return The peer for the specified Menu
object.
*/
protected abstract MenuPeer createMenu(Menu target);
/**
* Creates a peer object for the specified PopupMenu
.
*
* @param target The PopupMenu
to create the peer for.
* @return The peer for the specified PopupMenu
object.
*/
protected abstract PopupMenuPeer createPopupMenu(PopupMenu target);
/**
* Creates a peer object for the specified MenuItem
.
*
* @param target The MenuItem
to create the peer for.
* @return The peer for the specified MenuItem
object.
*/
protected abstract MenuItemPeer createMenuItem(MenuItem target);
/**
* Creates a peer object for the specified FileDialog
.
*
* @param target The FileDialog
to create the peer for.
* @return The peer for the specified FileDialog
object.
*/
protected abstract FileDialogPeer createFileDialog(FileDialog target);
/**
* Creates a peer object for the specified CheckboxMenuItem
.
*
* @param target The CheckboxMenuItem
to create the peer for.
* @return The peer for the specified CheckboxMenuItem
object.
*/
protected abstract CheckboxMenuItemPeer
createCheckboxMenuItem(CheckboxMenuItem target);
/**
* Creates a peer object for the specified Component
. The
* peer returned by this method is not a native windowing system peer
* with its own native window. Instead, this method allows the component
* to draw on its parent window as a "lightweight" widget.
*
* XXX: FIXME
*
* @param target The Component
to create the peer for.
* @return The peer for the specified Component
object.
*/
protected LightweightPeer createComponent(Component target)
{
return null;
}
/**
* Creates a peer object for the specified font name.
*
* @param name The font to create the peer for.
* @param style The font style to create the peer for.
* @return The peer for the specified font name.
*/
protected abstract FontPeer getFontPeer(String name, int style);
/**
* Copies the current system colors into the specified array. This is
* the interface used by the SystemColors
class.
*
* @param colors The array to copy the system colors into.
*/
protected void loadSystemColors(int systemColors[])
{
// XXX Implement.
}
/**
* @since 1.4
*/
public void setDynamicLayout(boolean dynamic)
{
}
/**
* @since 1.4
*/
protected boolean isDynamicLayoutSet()
{
return false;
}
/**
* @since 1.4
*/
public boolean isDynamicLayoutActive()
{
return false;
}
/**
* Returns the dimensions of the screen in pixels.
*
* @return The dimensions of the screen in pixels.
*/
public abstract Dimension getScreenSize();
/**
* Returns the screen resolution in dots per square inch.
*
* @return The screen resolution in dots per square inch.
*/
public abstract int getScreenResolution();
/**
* @since 1.4
*/
public Insets getScreenInsets(GraphicsConfiguration gc)
{
return null;
}
/**
* Returns the color model of the screen.
*
* @return The color model of the screen.
*/
public abstract ColorModel getColorModel();
/**
* Returns the names of the available fonts.
*
* @return The names of the available fonts.
*/
public abstract String[] getFontList();
/**
* Return the font metrics for the specified font
*
* @param name The name of the font to return metrics for.
* @return The requested font metrics.
*/
public abstract FontMetrics getFontMetrics(Font name);
/**
* Flushes any buffered data to the screen so that it is in sync with
* what the AWT system has drawn to it.
*/
public abstract void sync();
/**
* Returns an instance of the default toolkit. The default toolkit is
* the subclass of Toolkit
specified in the system property
* awt.toolkit
, or gnu.java.awt.peer.gtk.GtkToolkit
* if the property is not set.
*
* @return An instance of the system default toolkit.
* @throws AWTError If the toolkit cannot be loaded.
*/
public static Toolkit getDefaultToolkit()
{
if (toolkit != null)
return toolkit;
String toolkit_name = System.getProperty("awt.toolkit",
default_toolkit_name);
try
{
Class cls = Class.forName(toolkit_name);
Object obj = cls.newInstance();
if (!(obj instanceof Toolkit))
throw new AWTError(toolkit_name + " is not a subclass of " +
"java.awt.Toolkit");
toolkit = (Toolkit) obj;
return toolkit;
}
catch (Exception e)
{
throw new AWTError("Cannot load AWT toolkit: " + e.getMessage());
}
}
/**
* Returns an image from the specified file, which must be in a
* recognized format. Supported formats vary from toolkit to toolkit.
*
* @return name The name of the file to read the image from.
*/
public abstract Image getImage(String name);
/**
* Returns an image from the specified URL, which must be in a
* recognized format. Supported formats vary from toolkit to toolkit.
*
* @return url The URl to read the image from.
*/
public abstract Image getImage(URL url);
public abstract Image createImage(String filename);
public abstract Image createImage(URL url);
/**
* Readies an image to be rendered on the screen. The width and height
* values can be set to the default sizes for the image by passing -1
* in those parameters.
*
* @param image The image to prepare for rendering.
* @param width The width of the image.
* @param height The height of the image.
* @param observer The observer to receive events about the preparation
* process.
* @return true
if the image is already prepared for rendering,
* false
otherwise.
*/
public abstract boolean prepareImage(Image image, int width, int height,
ImageObserver observer);
/**
* Checks the status of specified image as it is being readied for
* rendering.
*
* @param image The image to prepare for rendering.
* @param width The width of the image.
* @param height The height of the image.
* @param observer The observer to receive events about the preparation
* process.
* @return A union of the bitmasks from
* java.awt.image.ImageObserver
that indicates the current
* state of the imaging readying process.
*/
public abstract int checkImage(Image image, int width, int height,
ImageObserver observer);
/**
* Creates an image using the specified ImageProducer
*
* @param producer The ImageProducer
to create the image from.
* @return The created image.
*/
public abstract Image createImage(ImageProducer producer);
/**
* Creates an image from the specified byte array. The array must be in
* a recognized format. Supported formats vary from toolkit to toolkit.
*
* @param data The raw image data.
* @return The created image.
*/
public Image createImage(byte[] data)
{
return createImage(data, 0, data.length);
}
/**
* Creates an image from the specified portion of the byte array passed.
* The array must be in a recognized format. Supported formats vary from
* toolkit to toolkit.
*
* @param data The raw image data.
* @param offset The offset into the data where the image data starts.
* @param len The length of the image data.
* @return The created image.
*/
public abstract Image createImage(byte[] data, int offset, int len);
/**
* Returns a instance of PrintJob
for the specified
* arguments.
*
* @param frame The window initiating the print job.
* @param title The print job title.
* @param props The print job properties.
* @return The requested print job, or null
if the job
* was cancelled.
*/
public abstract PrintJob getPrintJob(Frame frame, String title,
Properties props);
/**
* @since 1.3
*/
public PrintJob getPrintJob(Frame frame, String title,
JobAttributes jobAttr, PageAttributes pageAttr)
{
return null;
}
/**
* Causes a "beep" tone to be generated.
*/
public abstract void beep();
/**
* Returns the system clipboard.
*
* @return THe system clipboard.
*/
public abstract Clipboard getSystemClipboard();
/**
* @since 1.4
*/
public Clipboard getSystemSelection()
{
return null;
}
/**
* Returns the accelerator key mask for menu shortcuts. The default is
* Event.CTRL_MASK
. A toolkit must override this method
* to change the default.
*
* @return The key mask for the menu accelerator key.
*/
public int getMenuShortcutKeyMask()
{
return Event.CTRL_MASK;
}
public boolean getLockingKeyState(int keyCode)
{
if (keyCode != KeyEvent.VK_CAPS_LOCK
&& keyCode != KeyEvent.VK_NUM_LOCK
&& keyCode != KeyEvent.VK_SCROLL_LOCK)
throw new IllegalArgumentException();
throw new UnsupportedOperationException();
}
public void setLockingKeyState(int keyCode, boolean on)
{
if (keyCode != KeyEvent.VK_CAPS_LOCK
&& keyCode != KeyEvent.VK_NUM_LOCK
&& keyCode != KeyEvent.VK_SCROLL_LOCK)
throw new IllegalArgumentException();
throw new UnsupportedOperationException();
}
/**
* Returns the native container object of the specified component. This
* method is necessary because the parent component might be a lightweight
* component.
*
* @param component The component to fetch the native container for.
* @return The native container object for this component.
*/
protected static Container getNativeContainer(Component component)
{
component = component.getParent();
while (true)
{
if (component == null)
return null;
if (! (component instanceof Container))
{
component = component.getParent();
continue;
}
if (component.getPeer() instanceof LightweightPeer)
{
component = component.getParent();
continue;
}
return (Container) component;
}
}
public Cursor createCustomCursor(Image cursor, Point hotSpot, String name)
{
// Presumably the only reason this isn't abstract is for backwards
// compatibility? FIXME?
return null;
}
public Dimension getBestCursorSize(int preferredWidth, int preferredHeight)
{
return new Dimension (0,0);
}
public int getMaximumCursorColors()
{
return 0;
}
/**
* @since 1.4
*/
public boolean isFrameStateSupported(int state)
{
return false;
}
/**
* Returns the value of the property with the specified name, or the
* default value if the property does not exist.
*
* @param key The name of the property to retrieve.
* @param defThe default value of the property.
*/
public static String getProperty(String key, String def)
{
return props.getProperty(key, def);
}
/**
* Returns the event queue for the applet. Despite the word "System"
* in the name of this method, there is no guarantee that the same queue
* is shared system wide.
*
* @return The event queue for this applet (or application)
*/
public final EventQueue getSystemEventQueue()
{
return getSystemEventQueueImpl();
}
/**
* // FIXME: What does this do?
*/
protected abstract EventQueue getSystemEventQueueImpl();
/**
* @since 1.3
*/
public abstract DragSourceContextPeer
createDragSourceContextPeer(DragGestureEvent e);
/**
* @since 1.3
*/
public DragGestureRecognizer
createDragGestureRecognizer(Class recognizer, DragSource ds,
Component comp, int actions,
DragGestureListener l)
{
return null;
}
public final Object getDesktopProperty(String propertyName)
{
return desktopProperties.get(propertyName);
}
protected final void setDesktopProperty(String name, Object newValue)
{
Object oldValue = getDesktopProperty(name);
desktopProperties.put(name, newValue);
desktopPropsSupport.firePropertyChange(name, oldValue, newValue);
}
protected Object lazilyLoadDesktopProperty(String name)
{
// FIXME - what is this??
return null;
}
protected void initializeDesktopProperties()
{
// Overridden by toolkit implementation?
}
public void addPropertyChangeListener(String name,
PropertyChangeListener pcl)
{
desktopPropsSupport.addPropertyChangeListener(name, pcl);
}
public void removePropertyChangeListener(String name,
PropertyChangeListener pcl)
{
desktopPropsSupport.removePropertyChangeListener(name, pcl);
}
/**
* @since 1.4
*/
public PropertyChangeListener[] getPropertyChangeListeners()
{
return desktopPropsSupport.getPropertyChangeListeners();
}
/**
* @since 1.4
*/
public PropertyChangeListener[] getPropertyChangeListeners(String name)
{
return desktopPropsSupport.getPropertyChangeListeners(name);
}
public void addAWTEventListener(AWTEventListener listener, long eventMask)
{
// SecurityManager s = System.getSecurityManager();
// if (s != null)
// s.checkPermission(AWTPermission("listenToAllAWTEvents"));
// FIXME
}
public void removeAWTEventListener(AWTEventListener listener)
{
// FIXME
}
/**
* @since 1.4
*/
public AWTEventListener[] getAWTEventListeners()
{
return null;
}
/**
* @since 1.4
*/
public AWTEventListener[] getAWTEventListeners(long mask)
{
return null;
}
/**
* @since 1.3
*/
public abstract Map mapInputMethodHighlight(InputMethodHighlight highlight);
} // class Toolkit