toolkit.java

纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统

	/**
	 * Returns the dimensions of the screen in pixels.
	 * 
	 * @return The dimensions of the screen in pixels.
	 * 
	 * @exception HeadlessException
	 *                If GraphicsEnvironment.isHeadless() is true.
	 */
	public abstract Dimension getScreenSize();

	/**
	 * Returns the screen resolution in dots per square inch.
	 * 
	 * @return The screen resolution in dots per square inch.
	 * 
	 * @exception HeadlessException
	 *                If GraphicsEnvironment.isHeadless() is true.
	 */
	public abstract int getScreenResolution();

	/**
	 * @exception HeadlessException
	 *                If GraphicsEnvironment.isHeadless() is true.
	 * 
	 * @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 <code>Toolkit</code> specified in the system property <code>awt.toolkit</code>, or <code>gnu.java.awt.peer.gtk.GtkToolkit</code>
	 * 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 {
			final ClassLoader cl = Thread.currentThread().getContextClassLoader();
			final Class cls = cl.loadClass(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 <code>true</code> if the image is already prepared for rendering, <code>false</code> 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 <code>java.awt.image.ImageObserver</code> 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 <code>ImageProducer</code>
	 * 
	 * @param producer
	 *            The <code>ImageProducer</code> 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 <code>PrintJob</code> 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 <code>null</code> 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.
	 * 
	 * @exception HeadlessException
	 *                If GraphicsEnvironment.isHeadless() is true.
	 */
	public abstract Clipboard getSystemClipboard();

	/**
	 * @exception HeadlessException
	 *                If GraphicsEnvironment.isHeadless() is true.
	 * 
	 * @since 1.4
	 */
	public Clipboard getSystemSelection() {
		return null;
	}

	/**
	 * Returns the accelerator key mask for menu shortcuts. The default is <code>Event.CTRL_MASK</code>. A toolkit must override this method to change the default.
	 * 
	 * @return The key mask for the menu accelerator key.
	 * 
	 * @exception HeadlessException
	 *                If GraphicsEnvironment.isHeadless() is true.
	 */
	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