jncomponent.java

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

package org.jnode.wt.components;

import org.jnode.wt.decorators.JNCursor;
import org.jnode.wt.desktop.JNDesktopManager;
import org.jnode.wt.desktop.JNodeEvent;
import org.jnode.wt.events.JNComponentEvent;
import org.jnode.wt.events.JNPaintEvent;
import org.jnode.wt.events.JNodeKeyEvent;
import org.jnode.wt.events.JNodeMouseEvent;
import org.jnode.wt.events.JNKeyListener;
import org.jnode.wt.events.JNMouseListener;
import org.jnode.wt.events.JNMouseMotionListener;
import org.jnode.wt.components.AbstractValidatable;
import org.jnode.wt.components.Drawable;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Image;
import java.awt.GraphicsConfiguration;
import java.awt.AWTEvent;
import java.awt.Cursor;
import java.awt.Component;
import java.awt.BufferCapabilities;
import java.awt.event.PaintEvent;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.ColorModel;
import java.awt.image.VolatileImage;
import java.awt.peer.ComponentPeer;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.LinkedList;

/**
 * @author vali
 */
public abstract class JNComponent extends AbstractValidatable implements ComponentPeer, Drawable, MenuContainer, Serializable {

    /** The cursor for this component */
    private JNCursor cursor = null;
    /** The desktop manager */
    private final JNDesktopManager desktopMgr = JNDesktopManager.getDesktopManager();
    /** The parent of this component */
    private JNContainer parent = null;
    /** The bounds of this component */
    private Rectangle bounds = new Rectangle();
    /** Is this component enabled */
    private boolean enabled = true;
    /** Is this component visible */
    private boolean visible = true;
    /** Is this component opaque */
    private boolean opaque = true;
    /** The background color of this component */
    private Color background = Color.white;
    /** The foreground color of this component */
    private Color foreground = Color.black;
    /** All mouse listeners */
    private List mouseListeners = null;
    /** All mouse motion listeners */
    private List mouseMotionListeners = new LinkedList();
    /** All key motion listeners */
    private List keyListeners = null;

    /** The Font of this Component */
    private Font font = new Font("dialog", 0, 12);

    protected Insets comp_insets = new Insets(3, 10, 3, 10);

    /* This variable is prefered Size */
    protected Dimension preferredSize = null;
//	protected Dimension minimumSize = null;

    protected ArrayList listenerList = new ArrayList();


    private java.lang.String name = "";

    protected boolean drawBorderLine = true;

    /**
     * Add a mouse listener to this component.
     *
     * @param listener
     */
    public void addMouseListener(JNMouseListener listener) {
        if (mouseListeners == null) {
            mouseListeners = new ArrayList();
        }
        mouseListeners.add(listener);
    }

    public void addMouseMotionListener(org.jnode.wt.components.JNMouseMotionListener listener) {
        mouseMotionListeners.add(listener);
    }

    public void removeMouseMotionListener(org.jnode.wt.components.JNMouseMotionListener listener) {
        mouseMotionListeners.remove(listener);
    }


    /**
     * Does this component contain the given location relative to its parent.
     *
     * @param x
     * @param y
     * @return
     */
    public boolean contains(int x, int y) {
        return getBounds().contains(x, y);
    }

    public void dispatchEvent(JNodeEvent e) {
        processEvent(e);
    }

    public Rectangle getAbsBounds() {
        return new Rectangle(this.getAbsLocation().x, this.getAbsLocation().y, bounds.width, bounds.height);
    }

    public Point getAbsLocation() {
        JNComponent component = this;
        int x = 0, y = 0;

        do {
            if (component instanceof JNSimpleContainer) {
                x += component.getLocation().x;
                y += component.getLocation().y;
            } else {
                x += component.getLocation().x;
                y += component.getLocation().y;
            }
            component = component.getParent();

        } while (component != null);


        if (parent instanceof JNSimpleContainer) {
            if (((JNSimpleContainer) parent).getBorder() != null) {
                x += ((JNSimpleContainer) parent).getInsets().left;
                y += ((JNSimpleContainer) parent).getInsets().top;
            }
        }

        return new Point(x, y);
    }

    public Color getBackground() {
        return background;
    }

    /**
     * Get the bounds of this component relative to its parent.
     *
     * @return Rectangle
     */
    public Rectangle getBounds() {
        return bounds;
    }

    /*
    public final Rectangle getBounds() {
        return new Rectangle(location, new Dimension((int) size.getWidth() + 1, (int) size.getHeight() + 1));
    } */


    /**
     * @return Returns the cursor.
     */
    public JNCursor getCursor() {
        return this.cursor;
    }

    /**
     * Gets the desktop manager.
     * @return
     */
    public final JNDesktopManager getDesktopManager() {
        return desktopMgr;
    }

    public Font getFont() {
        return this.font;
    }

    public FontMetrics getFontMetrics() {
        return Toolkit.getDefaultToolkit().getFontMetrics(font);
    }

    public Color getForeground() {
        return this.foreground;
    }

    /**
     * Gets the graphics object to paint this component.
     */
    public Graphics getGraphics() {
        if (parent == null) {
            return desktopMgr.getGraphics();
        } else {
            return parent.getGraphics();
        }
    }

    public int getHeight() {
        return bounds.height;
    }

    public Insets getInsets() {
        return comp_insets;
    }

    /**
     * Gets the location of this component relative to its parent.
     *
     * @return Point
     */
    public Point getLocation() {
        return bounds.getLocation();
    }

    public Dimension getMinimumSize() {
/*	if(null == minimumSize)
	{
		minimumSize = new Dimension(0,0);
	}
	return minimumSize;
	*/

        return new Dimension(0, 0);
    }

    /**
     * Insert the method's description here.
     * Creation date: (1/24/04 2:14:21 AM)
     * @return java.lang.String
     */
    public java.lang.String getName() {
        return name;
    }

    /**
     * @return Returns the parent.
     */
    public final JNContainer getParent() {
        return parent;
    }

    public Dimension getPreferredSize() {
        if (null == preferredSize) {
//            preferredSize = calculatePreferredSize();
            preferredSize = new Dimension(0,0);
        }
        return preferredSize;
    }

    /**
     * @return Returns the size.
     */
    public Dimension getSize() {
        return new Dimension(bounds.width, bounds.height);
    }

    /*
    public Dimension getSize() {
        if (size == null) {
            return getPreferredSize();
        } else {
            return new Dimension(this.size);
        }
    } */


    public int getWidth() {
        return bounds.width;
    }

    public int getX() {
        return bounds.x;
    }

    public int getY() {
        return bounds.y;
    }

    protected void internallyPaint(Graphics g) {
        if (isOpaque()) {
            g.setColor(background);
            g.fillRect(0, 0, bounds.width, bounds.height);
            g.setColor(foreground);
        }
    }

    /**
     * Is this component enabled.
     *
     * @return boolean
     */
    public boolean isEnabled() {
        return enabled;
    }

    /**
     * Is this component opaque.
     *
     * @return True if this component is opaque, false if this component is transparent.
     */
    public final boolean isOpaque() {
        return opaque;
    }

    public boolean isShowing() {
        if (visible) {
            JNContainer parent = this.parent;

            if (parent == null) {
                return false;
            }

            return parent.isShowing();

        }
        return false;
    }

    /**
     * Is this component visible.
     *
     * @return
     */
    public boolean isVisible() {
        return visible;
    }

    /**
     * Process a component event.
     *
     * @param e
     */
    protected void processComponentEvent(JNComponentEvent e) {
        if (e.getID() == JNComponentEvent.COMPONENT_RESIZED) {
            this.validate();
        }
    }

    /**
     * Process an event.
     *
     * @param e
     */
    protected void processEvent(JNodeEvent e) {
        if (e instanceof JNPaintEvent)
            processPaintEvent((JNPaintEvent) e);
        else if (e instanceof JNodeMouseEvent) {
            if (e.getID() == JNodeMouseEvent.MOUSE_MOVED
                    || e.getID() == JNodeMouseEvent.MOUSE_DRAGGED)
                processMouseMotionEvent((JNodeMouseEvent) e);
            else
                processMouseEvent((JNodeMouseEvent) e);
        } else if (e instanceof JNComponentEvent)
            processComponentEvent((JNComponentEvent) e);
        else if (e instanceof JNodeKeyEvent)
            processKeyEvent((JNodeKeyEvent) e);

    }


    /**
     * Process a keyboard event.
     *
     * @param event
     */
    public void processKeyEvent(JNodeKeyEvent event) {
        if (keyListeners != null)
            for (Iterator it = keyListeners.iterator(); it.hasNext();) {
                JNKeyListener listener = (JNKeyListener) it.next();
                if (event.getID() == JNodeKeyEvent.KEY_PRESSED)
                    listener.keyPressed(event);
                else if (event.getID() == JNodeKeyEvent.KEY_RELEASED)
                    listener.keyReleased(event);
                else if (event.getID() == JNodeKeyEvent.KEY_TYPED)
                    listener.keyTyped(event);
            }
    }

    /**
     * Process a mouse event.
     *
     * @param event
     */
    protected void processMouseEvent(JNodeMouseEvent event) {
        if (mouseListeners != null)
            for (Iterator it = mouseListeners.iterator(); it.hasNext();) {
                JNMouseListener listener = (JNMouseListener) it.next();
                if (event.getID() == JNodeMouseEvent.MOUSE_CLICKED)
                    listener.mouseClicked(event);
                else if (event.getID() == JNodeMouseEvent.MOUSE_PRESSED)
                    listener.mousePressed(event);
                else if (event.getID() == JNodeMouseEvent.MOUSE_RELEASED)
                    listener.mouseReleased(event);
                else if (event.getID() == JNodeMouseEvent.MOUSE_ENTERED)
                    listener.mouseEntered(event);
                else if (event.getID() == JNodeMouseEvent.MOUSE_EXITED)
                    listener.mouseExited(event);

            }
    }

    /**
     * Process a mouse motion event.
     *
     * @param event
     */
    protected void processMouseMotionEvent(JNodeMouseEvent event) {
        if (mouseMotionListeners != null)
            for (Iterator it = mouseMotionListeners.iterator(); it.hasNext();) {
                JNMouseMotionListener listener = (JNMouseMotionListener) it.next();

                if (event.getID() == JNodeMouseEvent.MOUSE_DRAGGED)
                    listener.mouseDragged(event);
                else if (event.getID() == JNodeMouseEvent.MOUSE_MOVED)
                    listener.mouseMoved(event);