path: root/libjava/classpath/gnu/java/awt/peer/swing/SwingComponentPeer.java

/* SwingComponentPeer.java -- An abstract base class for Swing based peers
   Copyright (C)  2006, 2007  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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.swing;

import java.awt.AWTEvent;
import java.awt.AWTException;
import java.awt.BufferCapabilities;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.BufferCapabilities.FlipContents;
import java.awt.event.FocusEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.PaintEvent;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.VolatileImage;
import java.awt.peer.ComponentPeer;
import java.awt.peer.ContainerPeer;
import java.awt.peer.LightweightPeer;

import javax.swing.JComponent;
import javax.swing.RepaintManager;

/**
 * The base class for Swing based component peers. This provides the basic
 * functionality needed for Swing based component peers. Many methods are
 * implemented to forward to the Swing component. Others however forward
 * to the component's parent and expect the toplevel component peer to provide
 * a real implementation of it. These are for example the key methods
 * {@link #getGraphics()} and {@link #createImage(int, int)}, as well as
 * {@link #getLocationOnScreen()}.
 *
 * This class also provides the necesary hooks into the Swing painting and
 * event handling system. In order to achieve this, it traps paint, mouse and
 * key events in {@link #handleEvent(AWTEvent)} and calls some special methods
 * ({@link #peerPaint(Graphics)}, {@link #handleKeyEvent(KeyEvent)},
 * {@link #handleMouseEvent(MouseEvent)} and
 * {@link #handleMouseMotionEvent(MouseEvent)}) that call the corresponding
 * Swing methods.
 *
 * @author Roman Kennke (kennke@aicas.com)
 */
public class SwingComponentPeer
  implements ComponentPeer
{

  /**
   * The AWT component for this peer.
   */
  protected Component awtComponent;

  /**
   * The Swing component for this peer.
   */
  protected SwingComponent swingComponent;

  /**
   * The font that is set for this peer.
   */
  protected Font peerFont;

  /**
   * The current repaint area.
   */
  protected Rectangle paintArea;

 /**
   * Creates a SwingComponentPeer instance. Subclasses are expected to call
   * this constructor and thereafter call {@link #init(Component, JComponent)}
   * in order to setup the AWT and Swing components properly.
   */
  protected SwingComponentPeer()
  {
    // Nothing to do here.
  }

  /**
   * Initializes the AWT and Swing component for this peer. It is expected that
   * subclasses call this from within their constructor.
   *
   * @param awtComp the AWT component for this peer
   * @param swingComp the Swing component for this peer
   */
  protected void init(Component awtComp, SwingComponent swingComp)
  {
    awtComponent = awtComp;
    swingComponent = swingComp;
    if (swingComponent != null)
      {
        JComponent c = swingComponent.getJComponent();
        if (c != null)
          {
            c.addNotify();
            RepaintManager.currentManager(c).setDoubleBufferingEnabled(false);
            System.setProperty("gnu.awt.swing.doublebuffering", "true");
          }
      }

    // Register this heavyweight component with the nearest heavyweight
    // container, so we get peerPaint() triggered by that container.
    if (! (this instanceof LightweightPeer))
      {
        Component comp = awtComponent;
        Container parent = comp.getParent();
        while (parent != null &&
               ! (parent.getPeer() instanceof SwingContainerPeer))
          {
            comp = parent;
            parent = comp.getParent();
          }

        // At this point we have the ancestor with a SwingContainerPeer
        // (or null peer).
        if (parent != null && parent.getPeer() instanceof SwingContainerPeer)
          {
            SwingContainerPeer p = (SwingContainerPeer) parent.getPeer();
            p.addHeavyweightDescendent(awtComponent);
          }
      }
  }

  /**
   * Returns the construction status of the specified image. This is called
   * by {@link Component#checkImage(Image, int, int, ImageObserver)}.
   *
   * @param img the image
   * @param width the width of the image
   * @param height the height of the image
   * @param ob the image observer to be notified of updates of the status
   *
   * @return a bitwise ORed set of ImageObserver flags
   */
  public int checkImage(Image img, int width, int height, ImageObserver ob)
  {
    return Toolkit.getDefaultToolkit().checkImage(img, width, height, ob);
  }

  /**
   * Creates an image by starting the specified image producer. This is called
   * by {@link Component#createImage(ImageProducer)}.
   *
   * @param prod the image producer to be used to create the image
   *
   * @return the created image
   */
  public Image createImage(ImageProducer prod)
  {
    Image image = Toolkit.getDefaultToolkit().createImage(prod);
        return image;
  }

  /**
   * Creates an empty image with the specified <code>width</code> and
   * <code>height</code>.
   *
   * This is implemented to let the parent component create the image. This
   * eventually goes up to the top-level component peer, which is then expected
   * to deliver the image.
   *
   * @param width the width of the image to be created
   * @param height the height of the image to be created
   *
   * @return the created image
   */
  public Image createImage(int width, int height)
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    return parentPeer.createImage(width, height);
  }

  /**
   * Disables the component. This is called by {@link Component#disable()}.
   */
  public void disable()
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setEnabled(false);
  }

  /**
   * Disposes the component peer. This should release all resources held by the
   * peer. This is called when the component is no longer in use.
   */
  public void dispose()
  {
    // Unregister this heavyweight component from the nearest heavyweight
    // container.
    if (! (this instanceof LightweightPeer))
      {
        Component comp = awtComponent;
        Container parent = comp.getParent();
        while (parent != null &&
               ! (parent.getPeer() instanceof SwingContainerPeer))
          {
            comp = parent;
            parent = comp.getParent();
          }

        // At this point we have the ancestor with a SwingContainerPeer
        // (or null peer).
        if (parent != null && parent.getPeer() instanceof SwingContainerPeer)
          {
            SwingContainerPeer p = (SwingContainerPeer) parent.getPeer();
            p.removeHeavyweightDescendent(awtComponent);
          }
      }

    awtComponent = null;
    swingComponent = null;
  }

  /**
   * Enables the component. This is called by {@link Component#enable()}.
   */
  public void enable()
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setEnabled(true);
  }

  /**
   * Returns the color model of the component. This is currently not used.
   *
   * @return the color model of the component
   */
  public ColorModel getColorModel()
  {
    // FIXME: When this peer method will be used, we need to provide an
    // implementation of this, probably forwarding to the toplevel peer, like
    // in the other methods.
    return null;
  }

  /**
   * Returns the font metrics for the specified font. This is called by
   * {@link Component#getFontMetrics(Font)}.
   *
   * This is implemented to query the font metrics from the parent component.
   * This will eventually call the top-level component peer, which is then
   * expected to deliver a font metrics object.
   *
   * @param f the font for which to query the font metrics
   *
   * @return the font metrics for the specified font
   */
  public FontMetrics getFontMetrics(Font f)
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    return parentPeer.getFontMetrics(f);
  }

  /**
   * Returns a {@link Graphics} object suitable for drawing on this component.
   * This is called by {@link Component#getGraphics()}.
   *
   * This is implemented to query the graphics from the parent component and
   * adjust the clip and translation to match this component.
   * This will eventually call the top-level component peer, which is then
   * expected to deliver a graphics object.
   *
   * @return a graphics object suitable for drawing on this component
   */
  public Graphics getGraphics()
  {
    Component parent = awtComponent.getParent();
    Graphics g = parent.getGraphics();
    g.translate(awtComponent.getX(), awtComponent.getY());
    g.setClip(0, 0, awtComponent.getWidth(), awtComponent.getHeight());
    return g;
  }

  /**
   * Returns the location of this component in screen coordinates. This is
   * called by {@link Component#getLocationOnScreen()}.
   *
   * This is implemented to query the parent component peer for its screen
   * location and adds the offset of this component to it. This will eventually
   * call the top-level component's peer, which is then expected to provide
   * it's screen location.
   *
   * @return the location of this component in screen coordinates
   */
  public Point getLocationOnScreen()
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    Point location = parentPeer.getLocationOnScreen();
    location.x += awtComponent.getX();
    location.y += awtComponent.getY();
    return location;
  }

  /**
   * Returns the minimum size for the component. This is called by
   * {@link Component#getMinimumSize()}.
   *
   * This is implemented to return the Swing component's minimum size.
   *
   * @return the minimum size for the component
   */
  public Dimension getMinimumSize()
  {
    return minimumSize();
  }

  /**
   * Returns the preferred size for the component. This is called by
   * {@link Component#getPreferredSize()}.
   *
   * This is implemented to return the Swing component's preferred size.
   *
   * @return the preferred size for the component
   */
  public Dimension getPreferredSize()
  {
    return preferredSize();
  }

  /**
   * Returns the toolkit that created this peer.
   *
   * @return the toolkit that created this peer
   */
  public Toolkit getToolkit()
  {
    return Toolkit.getDefaultToolkit();
  }

  /**
   * Handles the given event. This is called from
   * {@link Component#dispatchEvent(AWTEvent)} to give the peer a chance to
   * react to events for the component.
   *
   * @param e the event
   */
  public void handleEvent(AWTEvent e)
  {
    switch (e.getID())
      {
      case PaintEvent.UPDATE:
      case PaintEvent.PAINT:
        if (awtComponent.isShowing())
          {
            Rectangle clip ;
            synchronized (this)
              {
                coalescePaintEvent((PaintEvent) e);
                assert paintArea != null;
                clip = paintArea;
                paintArea = null;
              }
            Graphics g = awtComponent.getGraphics();
            try
              {
                g.clipRect(clip.x, clip.y, clip.width, clip.height);
                peerPaint(g, e.getID() == PaintEvent.UPDATE);
              }
            finally
              {
                g.dispose();
              }
          }
        break;
      case MouseEvent.MOUSE_PRESSED:
      case MouseEvent.MOUSE_RELEASED:
      case MouseEvent.MOUSE_CLICKED:
      case MouseEvent.MOUSE_ENTERED:
      case MouseEvent.MOUSE_EXITED:
        handleMouseEvent((MouseEvent) e);
        break;
      case MouseEvent.MOUSE_MOVED:
      case MouseEvent.MOUSE_DRAGGED:
        handleMouseMotionEvent((MouseEvent) e);
        break;
      case KeyEvent.KEY_PRESSED:
      case KeyEvent.KEY_RELEASED:
      case KeyEvent.KEY_TYPED:
        handleKeyEvent((KeyEvent) e);
        break;
      case FocusEvent.FOCUS_GAINED:
      case FocusEvent.FOCUS_LOST:
        handleFocusEvent((FocusEvent)e);
        break;
      default:
        // Other event types are not handled here.
        break;
      }
  }

  /**
   * Makes the component invisible. This is called from
   * {@link Component#hide()}.
   *
   * This is implemented to call setVisible(false) on the Swing component.
   */
  public void hide()
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setVisible(false);

    Component parent = awtComponent.getParent();
    if (parent != null)
      parent.repaint(awtComponent.getX(), awtComponent.getY(),
                     awtComponent.getWidth(), awtComponent.getHeight());
  }

  /**
   * Returns <code>true</code> if the component can receive keyboard input
   * focus. This is called from {@link Component#isFocusTraversable()}.
   *
   * This is implemented to return isFocusable() from the Swing component.
   *
   * @specnote Part of the earlier 1.1 API, replaced by isFocusable().
   */
  public boolean isFocusTraversable()
  {
    return swingComponent != null ?
             swingComponent.getJComponent().isFocusable() : false;
  }

  /**
   * Returns <code>true</code> if the component can receive keyboard input
   * focus. This is called from {@link Component#isFocusable()}.
   *
   * This is implemented to return isFocusable() from the Swing component.
   */
  public boolean isFocusable()
  {
    return swingComponent != null ?
             swingComponent.getJComponent().isFocusable() : false;
  }

  /**
   * Returns the minimum size for the component. This is called by
   * {@link Component#minimumSize()}.
   *
   * This is implemented to return the Swing component's minimum size.
   *
   * @return the minimum size for the component
   */
  public Dimension minimumSize()
  {
    Dimension retVal;
    if (swingComponent != null)
      retVal = swingComponent.getJComponent().getMinimumSize();
    else
      retVal = new Dimension(0, 0);
    return retVal;
  }

  /**
   * Returns the preferred size for the component. This is called by
   * {@link Component#getPreferredSize()}.
   *
   * This is implemented to return the Swing component's preferred size.
   *
   * @return the preferred size for the component
   */
  public Dimension preferredSize()
  {
    Dimension retVal;
    if (swingComponent != null)
      retVal = swingComponent.getJComponent().getPreferredSize();
    else
      retVal = new Dimension(0, 0);
    return retVal;
  }

  /**
   * Paints the component. This is triggered by
   * {@link Component#paintAll(Graphics)}.
   *
   * @param graphics the graphics to paint with
   */
  public void paint(Graphics graphics)
  {
    peerPaint(graphics, false);
  }

  /**
   * Prepares an image for rendering on this component. This is called by
   * {@link Component#prepareImage(Image, int, int, ImageObserver)}.
   *
   * @param img the image to prepare
   * @param width the desired width of the rendered image
   * @param height the desired height of the rendered image
   * @param ob the image observer to be notified of updates in the preparation
   *        process
   *
   * @return <code>true</code> if the image has been fully prepared,
   *         <code>false</code> otherwise (in which case the image observer
   *         receives updates)
   */
  public boolean prepareImage(Image img, int width, int height, ImageObserver ob)
  {
    Component parent = awtComponent.getParent();
    if(parent != null)
    {
      ComponentPeer parentPeer = parent.getPeer();
      return parentPeer.prepareImage(img, width, height, ob);
    }
    else
    {
      return Toolkit.getDefaultToolkit().prepareImage(img, width, height, ob);
    }
  }

  public void print(Graphics graphics)
  {
    // FIXME: I don't know what this method is supposed to do.
  }

  /**
   * Repaints the specified rectangle of this component. This is called from
   * {@link Component#repaint(long, int, int, int, int)}.
   *
   * This is implemented to call repaint() on the Swing component.
   *
   * @param tm number of milliseconds to wait with repainting
   * @param x the X coordinate of the upper left corner of the damaged
   *        rectangle
   * @param y the Y coordinate of the upper left corner of the damaged
   *        rectangle
   * @param width the width of the damaged rectangle
   * @param height the height of the damaged rectangle
   */
  public void repaint(long tm, int x, int y, int width, int height)
  {
    // NOTE: This is never called by AWT but is mandated by the peer interface.
    if (swingComponent != null)
      swingComponent.getJComponent().repaint(tm, x, y, width, height);
    else
      {
        PaintEvent ev = new PaintEvent(awtComponent, PaintEvent.UPDATE,
                                       new Rectangle(x, y, width, height));
        Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(ev);
      }
  }

  /**
   * Requests that this component receives the focus. This is called from
   * {@link Component#requestFocus()}.
   *
   * This calls requestFocus() on the Swing component.
   *
   * @specnote Part of the earlier 1.1 API, apparently replaced by argument
   *           form of the same method.
   */
  public void requestFocus()
  {
    // NOTE: This is never called by AWT but is mandated by the peer interface.
    Toolkit tk = Toolkit.getDefaultToolkit();
    EventQueue q = tk.getSystemEventQueue();
    q.postEvent(new FocusEvent(awtComponent, FocusEvent.FOCUS_GAINED, false));
  }

  /**
   * Requests that this component receives the focus. This is called from
   * {@link Component#requestFocus()}.
   *
   * This calls requestFocus() on the Swing component.
   *
   * @param source the actual component that requests focus (may be a
   *        lightweight descendant of the heavyweight container)
   * @param tmp true when the change is temporary
   * @param allowWindowFocus
   * @param tm the timestamp of the focus change
   *
   * @return true when the focus change is guaranteed to be granted, false
   *         otherwise
   */
  public boolean requestFocus(Component source, boolean tmp,
                              boolean allowWindowFocus, long tm)
  {
    Toolkit tk = Toolkit.getDefaultToolkit();
    EventQueue q = tk.getSystemEventQueue();
    q.postEvent(new FocusEvent(source, FocusEvent.FOCUS_GAINED, tmp));
    return true;
  }

  /**
   * Notifies the peer that the bounds of this component have changed. This
   * is called by {@link Component#reshape(int, int, int, int)}.
   *
   * This is implemented to call setBounds() on the Swing component.
   *
   * @param x the X coordinate of the upper left corner of the component
   * @param y the Y coordinate of the upper left corner of the component
   * @param width the width of the component
   * @param height the height of the component
   */
  public void reshape(int x, int y, int width, int height)
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setBounds(x, y, width, height);
  }

  /**
   * Sets the background color of the component. This is called by
   * {@link Component#setBackground(Color)}.
   *
   * This is implemented to call setBackground() on the Swing component.
   *
   * @param color the background color to set
   */
  public void setBackground(Color color)
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setBackground(color);
  }

  /**
   * Notifies the peer that the bounds of this component have changed. This
   * is called by {@link Component#setBounds(int, int, int, int)}.
   *
   * This is implemented to call setBounds() on the Swing component.
   *
   * @param x the X coordinate of the upper left corner of the component
   * @param y the Y coordinate of the upper left corner of the component
   * @param width the width of the component
   * @param height the height of the component
   */
  public void setBounds(int x, int y, int width, int height)
  {
    reshape(x, y, width, height);
  }

  /**
   * Sets the cursor of the component. This is called by
   * {@link Component#setCursor(Cursor)}.
   *
   * This is implemented to call setCursor() on the Swing component.
   *
   * @specnote Part of the earlier 1.1 API, apparently no longer needed.
   */
  public void setCursor(Cursor cursor)
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setCursor(cursor);
  }

  /**
   * Sets the enabled/disabled state of this component. This is called by
   * {@link Component#setEnabled(boolean)}.
   *
   * This is implemented to call setEnabled() on the Swing component.
   *
   * @param enabled <code>true</code> to enable the component,
   *        <code>false</code> to disable it
   */
  public void setEnabled(boolean enabled)
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setEnabled(enabled);
  }

  /**
   * Sets the font of the component. This is called by
   * {@link Component#setFont(Font)}.
   *
   * This is implemented to call setFont() on the Swing component.
   *
   * @param font the font to set
   */
  public void setFont(Font font)
  {
    peerFont = font;
    if (swingComponent != null)
      swingComponent.getJComponent().setFont(font);
  }

  /**
   * Sets the foreground color of the component. This is called by
   * {@link Component#setForeground(Color)}.
   *
   * This is implemented to call setForeground() on the Swing component.
   *
   * @param color the foreground color to set
   */
  public void setForeground(Color color)
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setForeground(color);
  }

  /**
   * Sets the visibility state of the component. This is called by
   * {@link Component#setVisible(boolean)}.
   *
   * This is implemented to call setVisible() on the Swing component.
   *
   * @param visible <code>true</code> to make the component visible,
   *        <code>false</code> to make it invisible
   */
  public void setVisible(boolean visible)
  {
    if (visible)
      show();
    else
      hide();
  }

  /**
   * Makes the component visible. This is called by {@link Component#show()}.
   *
   * This is implemented to call setVisible(true) on the Swing component.
   */
  public void show()
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setVisible(true);
  }

  /**
   * Get the graphics configuration of the component. The color model
   * of the component can be derived from the configuration.
   *
   * This is implemented to return the GraphicsConfiguration of the parent
   * component. This will eventually call the toplevel component peer, which
   * is expected to provide a real implementation.
   *
   * @return the graphics configuration of the component
   */
  public GraphicsConfiguration getGraphicsConfiguration()
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    return parentPeer.getGraphicsConfiguration();
  }

  /**
   * Part of an older API, no longer needed.
   */
  public void setEventMask(long mask)
  {
    // Nothing to do here.
  }

  /**
   * Returns <code>true</code> if this component has been obscured,
   * <code>false</code> otherwise. This will only work if
   * {@link #canDetermineObscurity()} also returns <code>true</code>.
   *
   * This is not yet implemented.
   *
   * @return <code>true</code> if this component has been obscured,
   *         <code>false</code> otherwise.
   */
  public boolean isObscured()
  {
    return false;
  }

  /**
   * Returns <code>true</code> if this component peer can determine if the
   * component has been obscured, <code>false</code> otherwise.
   *
   * This is not yet implemented.
   *
   * @return <code>true</code> if this component peer can determine if the
   *         component has been obscured, <code>false</code> otherwise
   */
  public boolean canDetermineObscurity()
  {
    return false;
  }

  /**
   * Coalesces the specified paint event.
   *
   * @param e the paint event
   */
  public void coalescePaintEvent(PaintEvent e)
  {
    synchronized (this)
      {
        Rectangle newRect = e.getUpdateRect();
        if (paintArea == null)
          paintArea = newRect;
        else
          Rectangle.union(paintArea, newRect, paintArea);
      }
  }

  /**
   * Updates the cursor. This is not yet implemented.
   */
  public void updateCursorImmediately()
  {
    // Nothing to do here yet.
  }

  /**
   * Returns true, if this component can handle wheel scrolling,
   * <code>false</code> otherwise.
   *
   * This is not yet implemented and returns <code>false</code>.
   *
   * @return true, if this component can handle wheel scrolling,
   *         <code>false</code> otherwise
   */
  public boolean handlesWheelScrolling()
  {
    return false;
  }

  /**
   * A convenience method that creates a volatile image.  The volatile
   * image is created on the screen device on which this component is
   * displayed, in the device's current graphics configuration.
   *
   * This is implemented to let the parent component peer create an image.
   * This eventually ends up in the toplevel component peer, which is then
   * responsible for creating the real image.
   *
   * @param width width of the image
   * @param height height of the image
   *
   * @see VolatileImage
   *
   * @since 1.2
   */
  public VolatileImage createVolatileImage(int width, int height)
  {
    Component parent = awtComponent.getParent();
    VolatileImage im = null;
    if (parent != null)
      {
        ComponentPeer parentPeer = parent.getPeer();
        im = parentPeer.createVolatileImage(width, height);
      }
    return im;
  }

  /**
   * Create a number of image buffers that implement a buffering
   * strategy according to the given capabilities.
   *
   * This is implemented to forward to the parent component peer. Eventually
   * this ends up in the top level component peer, which is then responsible
   * for doing the real work.
   *
   * @param numBuffers the number of buffers
   * @param caps the buffering capabilities
   *
   * @throws AWTException if the specified buffering strategy is not
   * implemented
   *
   * @since 1.2
   */
  public void createBuffers(int numBuffers, BufferCapabilities caps) throws AWTException
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    parentPeer.createBuffers(numBuffers, caps);
  }

  /**
   * Return the back buffer of this component.
   *
   * This is implemented to forward to the parent. Eventually this ends
   * up in the toplevel component, which is then responsible for providing
   * a back buffer.
   *
   * @return the back buffer of this component.
   *
   * @since 1.2
   */
  public Image getBackBuffer()
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    return parentPeer.getBackBuffer();
  }

  /**
   * Perform a page flip, leaving the contents of the back buffer in
   * the specified state.
   *
   * This is implemented to forward to the parent. Eventually this ends
   * up in the toplevel component, which is then responsible for doing the real
   * work.
   *
   * @param contents the state in which to leave the back buffer
   *
   * @since 1.2
   */
  public void flip(FlipContents contents)
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    parentPeer.flip(contents);
  }

  /**
   * Destroy the resources created by createBuffers.
   *
   * This is implemented to forward to the parent component peer. Eventually
   * this ends up in the top level component peer, which is then responsible
   * for doing the real work.
   *
   * @since 1.2
   */
  public void destroyBuffers()
  {
    Component parent = awtComponent.getParent();
    ComponentPeer parentPeer = parent.getPeer();
    parentPeer.destroyBuffers();
  }

  /**
   * Get the bounds of this component peer.
   *
   * This is implemented to forward to the Swing component.
   *
   * @return component peer bounds
   * @since 1.5
   */
  public Rectangle getBounds()
  {
    Rectangle retVal;
    if (swingComponent != null)
      retVal = swingComponent.getJComponent().getBounds();
    else
      retVal = new Rectangle();
    return retVal;
  }

  /**
   * Reparent this component under another container.
   *
   * @param parent
   * @since 1.5
   */
  public void reparent(ContainerPeer parent)
  {
    // Nothing to do here.
  }

  /**
   * Set the bounds of this component peer.
   *
   * This is implemented to forward to the swing component.
   *
   * @param x the new x co-ordinate
   * @param y the new y co-ordinate
   * @param width the new width
   * @param height the new height
   * @param z the new stacking level
   * @since 1.5
   */
  public void setBounds(int x, int y, int width, int height, int z)
  {
    if (swingComponent != null)
      swingComponent.getJComponent().setBounds(x, y, width, height);
    // FIXME: Somehow handle the Z order.
  }

  /**
   * Check if this component supports being reparented.
   *
   * @return true if this component can be reparented,
   * false otherwise.
   * @since 1.5
   */
  public boolean isReparentSupported()
  {
    return true;
  }


  /**
   * Layout this component peer.
   *
   * @since 1.5
   */
  public void layout()
  {
    if (swingComponent != null)
      swingComponent.getJComponent().doLayout();
  }

  /**
   * Triggers 'heavyweight' painting of the components. This usually calls
   * paint() on the Swing component.
   *
   * @param g the graphics context to use for painting
   * @param update wether we need to call update or paint on the AWT component
   */
  protected void peerPaint(Graphics g, boolean update)
  {
    peerPaintComponent(g);

    Graphics userGraphics = g.create();
    try{
    if (update)
      awtComponent.update(userGraphics);
    else
      awtComponent.paint(userGraphics);
    } finally {
        userGraphics.dispose();
    }

  }

  /**
   * Paints the actual 'heavyweight' swing component, if there is one
   * associated to this peer.
   *
   * @param g the graphics to paint the component with
   */
  protected void peerPaintComponent(Graphics g)
  {
    // Paint the actual Swing component if this peer has one.
    if (swingComponent != null)
      swingComponent.getJComponent().paint(g);
  }

  /**
   * Handles mouse events on the component. This is usually forwarded to the
   * SwingComponent's processMouseEvent() method.
   *
   * @param e the mouse event
   */
  protected void handleMouseEvent(MouseEvent e)
  {
    if (swingComponent != null)
      swingComponent.handleMouseEvent(e);
  }

  /**
   * Handles mouse motion events on the component. This is usually forwarded
   * to the SwingComponent's processMouseMotionEvent() method.
   *
   * @param e the mouse motion event
   */
  protected void handleMouseMotionEvent(MouseEvent e)
  {
    if (swingComponent != null)
      swingComponent.handleMouseMotionEvent(e);
  }

  /**
   * Handles key events on the component. This is usually forwarded to the
   * SwingComponent's processKeyEvent() method.
   *
   * @param e the key event
   */
  protected void handleKeyEvent(KeyEvent e)
  {
    if (swingComponent != null)
      swingComponent.handleKeyEvent(e);
  }

  /**
   * Handles focus events on the component. This is usually forwarded to the
   * SwingComponent's processFocusEvent() method.
   *
   * @param e the key event
   */
  protected void handleFocusEvent(FocusEvent e)
  {
    if (swingComponent != null)
      swingComponent.handleFocusEvent(e);
  }


  /**
   * Returns the AWT component for this peer.
   *
   * @return the AWT component for this peer
   */
  public Component getComponent()
  {
    return awtComponent;
  }

  public boolean requestFocus(Component lightweightChild, boolean temporary,
                              boolean focusedWindowChangeAllowed,
                              long time, sun.awt.CausedFocusEvent.Cause cause)
  {
    return true;
  }

}