jnodecomponentpeer.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 553 行

/*
 * $Id: JNodeComponentPeer.java,v 1.1 2003/11/25 11:51:36 epr Exp $
 */
package org.jnode.awt.peer;

import java.awt.AWTEvent;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.ScrollPane;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.ComponentEvent;
import java.awt.event.PaintEvent;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.peer.ComponentPeer;

import org.jnode.awt.image.JNodeImage;
import org.jnode.util.ObjectUtils;

/**
 * @author epr
 */
public class JNodeComponentPeer extends JNodeGenericPeer implements ComponentPeer {

	private static final Font DEFAULT_FONT = new Font("Dialog", Font.PLAIN, 10);

	private final Component awtComponent;
	private Color bgColor = Color.LIGHT_GRAY;
	private Color fgColor = Color.BLACK;
	private int x;
	private int y;
	private int width;
	private int height;
	private boolean enabled = true;
	private long eventMask = 0xFFFFFFFFFFFFFFFFL;
	private boolean visible = true;
	private Font font = DEFAULT_FONT;
	private Cursor cursor = Cursor.getDefaultCursor();
	private boolean ready = true;

	/**
	 * @param toolkit
	 * @param awtObject
	 */
	public JNodeComponentPeer(JNodeToolkit toolkit, Component awtObject) {
		super(toolkit, awtObject);
		this.awtComponent = awtObject;
		setEnabled(awtObject.isEnabled());
		setVisible(awtObject.isVisible());
	}

	/**
	 * @param img
	 * @param width
	 * @param height
	 * @param ob
	 * @see java.awt.peer.ComponentPeer#checkImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
	 * @return
	 */
	public int checkImage(Image img, int width, int height, ImageObserver ob) {
		// TODO Auto-generated method stub
		return 0;
	}

	/**
	 * @param prod
	 * @see java.awt.peer.ComponentPeer#createImage(java.awt.image.ImageProducer)
	 * @return The image
	 */
	public Image createImage(ImageProducer prod) {
		return new JNodeImage(prod);
	}

	/**
	 * @param width
	 * @param height
	 * @see java.awt.peer.ComponentPeer#createImage(int, int)
	 * @return The image
	 */
	public Image createImage(int width, int height) {
		return new JNodeImage(width, height);
	}

	/**
	 * @see java.awt.peer.ComponentPeer#disable()
	 */
	public final void disable() {
		setEnabled(false);
	}

	/**
	 * @see java.awt.peer.ComponentPeer#enable()
	 */
	public final void enable() {
		setEnabled(true);
	}

	protected final boolean isEnabled() {
		return enabled;
	}

	/**
	 * @see java.awt.peer.ComponentPeer#getColorModel()
	 * @return the color model
	 */
	public final ColorModel getColorModel() {
		return getGraphicsConfiguration().getColorModel();
	}

	/**
	 * @param f
	 * @see java.awt.peer.ComponentPeer#getFontMetrics(java.awt.Font)
	 * @return the metrics
	 */
	public final FontMetrics getFontMetrics(Font f) {
		return Toolkit.getDefaultToolkit().getFontMetrics(f);
	}

	/**
	 * @see java.awt.peer.ComponentPeer#getGraphics()
	 * @return The graphics
	 */
	public final Graphics getGraphics() {
		return new JNodeGraphics(this);
	}

	/**
	 * Gets a valid JNodeGraphics object that enables this peer to paint itself.
	 * @return the graphics
	 */
	protected final JNodeGraphics getJNodeGraphics() {
		int tx = 0;
		int ty = 0;
		int sx = 0;
		int sy = 0;
		//Dimension viewPort = null;
		Component c = awtComponent;

		// find direct window connection
		while (!(c instanceof Frame)) {
			// adjust translation coords
			Rectangle bounds = c.getBounds();
			tx += bounds.x;
			ty += bounds.y;
			// check if component is (real) child of ScrollPane
			// and prepare JXGraphics scroll coords
			if (c.getParent() instanceof ScrollPane && (c != ((ScrollPane) c.getParent()).getHAdjustable() && c != ((ScrollPane) c.getParent()).getVAdjustable())) {
				// NOTE: supports only one ScrollPane in container hierarchy!!!
				//viewPort = ((ScrollPane) c.getParent()).getViewportSize();
				// adjust scroll coords
				Point p = ((JNodeScrollPanePeer) c.getParent().getJNodePeer()).getScrollPosition();
				sx -= p.x;
				sy -= p.y;
			}
			c = c.getParent();
		}
		// get JXGraphics object from underlying Window
		JNodeGraphics g = (JNodeGraphics) ((JNodeFramePeer) c.getJNodePeer()).getGraphics();
		// set viewport clip if necessary
		/*if (viewPort != null) {
			Point p = g.getTranslationOrigin();
			p.x += tx;
			p.y += ty;
			//System.out.println("Origin is " + p + ",viewPort is " + viewPort);
			g.setViewClip(p.x, p.y, viewPort.width, viewPort.height);
		}*/
		// set coords and user clip
		g.translate(tx + sx, ty + sy);
		g.setClip(0, 0, width, height);
		return g;
	}

	/**
	 * @see java.awt.peer.ComponentPeer#getGraphicsConfiguration()
	 * @return The configuration
	 */
	public final GraphicsConfiguration getGraphicsConfiguration() {
		return toolkit.getGraphicsConfiguration();
	}

	/**
	 * @see java.awt.peer.ComponentPeer#getLocationOnScreen()
	 * @return The location on screen
	 */
	public Point getLocationOnScreen() {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * @see java.awt.peer.ComponentPeer#getMinimumSize()
	 * @return The minimum size
	 */
	public Dimension getMinimumSize() {
		return new Dimension(50, 20);
	}

	/**
	 * @see java.awt.peer.ComponentPeer#getPreferredSize()
	 * @return The preferred size
	 */
	public Dimension getPreferredSize() {
		return new Dimension(50, 20);
	}

	/**
	 * @param event
	 * @see java.awt.peer.ComponentPeer#handleEvent(java.awt.AWTEvent)
	 */
	public void handleEvent(AWTEvent event) {
		switch (event.getID()) {
			case PaintEvent.PAINT: {
				awtComponent.paint(getGraphics());
			} break;
			case PaintEvent.UPDATE: {
				awtComponent.update(getGraphics());
			} break;
		}
	}

	/**
	 * @see java.awt.peer.ComponentPeer#hide()
	 */
	public final void hide() {
		setVisible(false);
	}

	/**
	 * @see java.awt.peer.ComponentPeer#isFocusTraversable()
	 * @return boolean
	 */
	public boolean isFocusTraversable() {
		return false;
	}

	/**
	 * @see java.awt.peer.ComponentPeer#minimumSize()
	 * @return The minimum size
	 */
	public final Dimension minimumSize() {
		return getMinimumSize();
	}

	/**
	 * @param g
	 * @see java.awt.peer.ComponentPeer#paint(java.awt.Graphics)
	 */
	public void paint(Graphics g) {
	}

	/**
	 * @see java.awt.peer.ComponentPeer#preferredSize()
	 * @return The preferred size
	 */
	public final Dimension preferredSize() {
		return getPreferredSize();
	}

	/**
	 * @param img
	 * @param width
	 * @param height
	 * @param ob
	 * @see java.awt.peer.ComponentPeer#prepareImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
	 * @return boolean
	 */
	public boolean prepareImage(Image img, int width, int height, ImageObserver ob) {
		// TODO Auto-generated method stub
		return false;
	}

	/**
	 * @param graphics
	 * @see java.awt.peer.ComponentPeer#print(java.awt.Graphics)
	 */
	public void print(Graphics graphics) {
		awtComponent.paint(graphics);
	}

	/**
	  * Starts the painting of this peer and its child peers. This
	  * method is called whenever a peer needs to be repainted.
	  */
	public final void redraw() {
		//System.out.println("redraw on " + this);
		if (ready) {
			redrawComponent();
		}
	}

	/**
	 * Repaints this peer. This method should never be overriden by a peer!
	 * To write own painting code, override the paint(Graphics) method.
	 */
	protected void redrawComponent() {
		//System.out.println("redrawComponent on " + this + " visible=" + visible);
		final Graphics g = getGraphics();
		// do all component depending painting if component
		// is visible
		if (visible) {
			// paint Peer
			paint(g);
			// paint AWT Component
			final EventQueue queue = toolkit.getSystemEventQueue();
			queue.postEvent(new PaintEvent(awtComponent, PaintEvent.PAINT, new Rectangle(x, y, width, height)));
		} else {
			paintInvisibleComponent(g);
		}
	}

	/**
	 * Paints an invisible peer.
	 * @param g
	 */
	protected void paintInvisibleComponent(Graphics g) {
		g.setColor(bgColor);
		g.fillRect(0, 0, width, height);
	}

	/**
	 * @param tm
	 * @param x
	 * @param y
	 * @param width
	 * @param height
	 * @see java.awt.peer.ComponentPeer#repaint(long, int, int, int, int)
	 */
	public final void repaint(long tm, int x, int y, int width, int height) {
		redraw();
	}

	/**
	 * @see java.awt.peer.ComponentPeer#requestFocus()
	 */
	public void requestFocus() {
		// save old focus component
		JNodeComponentPeer oldFocusPeer;
		Component fc = toolkit.getFocusHandler().getFocusedComponent();
		if (fc != null) {
			oldFocusPeer = (JNodeComponentPeer) fc.getJNodePeer();
		} else {
			oldFocusPeer = null;
		}
		// set new focus
		setFocus();
		// redraw new and (if necessary) old focus component
		// Note that Window derived classes can also request
		// focus, but are not traversable to focus.
		if (oldFocusPeer != null && oldFocusPeer.isFocusTraversable()) {
			oldFocusPeer.redraw();
		}
		if (isFocusTraversable()) {
			redraw();
		}
	}

	/** Sets the keyboard focus to this peer */
	public void setFocus() {
		toolkit.getFocusHandler().setFocusedComponent(awtComponent);
	}

	/**
	 * @param x
	 * @param y
	 * @param width
	 * @param height
	 * @see java.awt.peer.ComponentPeer#reshape(int, int, int, int)
	 */
	public final void reshape(int x, int y, int width, int height) {
		setBounds(x, y, width, height);
	}

	/**
	 * @param color
	 * @see java.awt.peer.ComponentPeer#setBackground(java.awt.Color)
	 */
	public final void setBackground(Color color) {
		if (!ObjectUtils.equals(this.bgColor, color)) {
			this.bgColor = color;
			redraw();
		}
	}

	protected final Color getBackground() {
		return bgColor;
	}

	/**
	 * @param x
	 * @param y
	 * @param width
	 * @param height
	 * @see java.awt.peer.ComponentPeer#setBounds(int, int, int, int)
	 */
	public void setBounds(int x, int y, int width, int height) {
		this.x = x;
		this.y = y;
		this.width = width;
		this.height = height;
		if (this.width != width || this.height != height) {
			sendComponentEvent(ComponentEvent.COMPONENT_RESIZED);
		} else {
			sendComponentEvent(ComponentEvent.COMPONENT_MOVED);
		}
	}

	protected final int getX() {
		return x;
	}

	protected final int getY() {
		return y;
	}

	protected final int getWidth() {
		return width;
	}

	protected final int getHeight() {
		return height;
	}

	/**
	 * @param cursor
	 * @see java.awt.peer.ComponentPeer#setCursor(java.awt.Cursor)
	 */
	public void setCursor(Cursor cursor) {
		if (!ObjectUtils.equals(this.cursor, cursor)) {
			this.cursor = cursor;
		}
	}

	protected final Cursor getCursor() {
		return cursor;
	}

	/**
	 * @param enabled
	 * @see java.awt.peer.ComponentPeer#setEnabled(boolean)
	 */
	public final void setEnabled(boolean enabled) {
		if (this.enabled != enabled) {
			this.enabled = enabled;
			redraw();
		}
	}

	/**
	 * @param mask
	 * @see java.awt.peer.ComponentPeer#setEventMask(long)
	 */
	public final void setEventMask(long mask) {
		this.eventMask = mask;
	}

	protected final long getEventMask() {
		return eventMask;
	}

	/**
	 * @param font
	 * @see java.awt.peer.ComponentPeer#setFont(java.awt.Font)
	 */
	public final void setFont(Font font) {
		if (!ObjectUtils.equals(this.font, font)) {
			this.font = font;
			redraw();
		}
	}

	protected final Font getFont() {
		return font;
	}

	/**
	 * @param color
	 * @see java.awt.peer.ComponentPeer#setForeground(java.awt.Color)
	 */
	public final void setForeground(Color color) {
		if (!ObjectUtils.equals(this.fgColor, color)) {
			this.fgColor = color;
			redraw();
		}
	}

	protected final Color getForeground() {
		return fgColor;
	}

	/**
	 * @param visible
	 * @see java.awt.peer.ComponentPeer#setVisible(boolean)
	 */
	public final void setVisible(boolean visible) {
		if (this.visible != visible) {
			this.visible = visible;
			redraw();
		}
	}

	protected final boolean isVisible() {
		return visible;
	}

	/**
	 * @see java.awt.peer.ComponentPeer#show()
	 */
	public final void show() {
		setVisible(true);
	}

	/**
	 * @return The AWT component this peer belongs to
	 */
	protected final Component getAwtComponent() {
		return this.awtComponent;
	}

	/**
	 * Posts a component event to the AWT event queue.
	 * @param what
	 */
	protected final void sendComponentEvent(int what) {
		final EventQueue queue = toolkit.getSystemEventQueue();
		queue.postEvent(new ComponentEvent(awtComponent, what));
	}

	/**
	 * Gets the window this peers component is contained in
	 * @return The host window
	 */
	protected final Window getHostWindow() {
		Component c = awtComponent;
		while (!(c instanceof Window)) {
			c = c.getParent();
		}
		return (Window) c;
	}
}