Logo Search packages:      
Sourcecode: classpath version File versions

BasicInternalFrameUI.java

/* BasicInternalFrameUI.java --
   Copyright (C) 2004 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 javax.swing.plaf.basic;

import java.awt.AWTEvent;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.DefaultDesktopManager;
import javax.swing.DesktopManager;
import javax.swing.JComponent;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.KeyStroke;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.border.AbstractBorder;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;
import javax.swing.event.MouseInputAdapter;
import javax.swing.event.MouseInputListener;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.InternalFrameUI;
import javax.swing.plaf.UIResource;

/**
 * This is the UI delegate for the Basic look and feel for JInternalFrames.
 */
00077 public class BasicInternalFrameUI extends InternalFrameUI
{
  /**
   * This is a helper class that listens to the JInternalFrame for
   * InternalFrameEvents.
   */
00083   protected class BasicInternalFrameListener implements InternalFrameListener
  {
    /**
     * This method is called when the JInternalFrame is activated.
     *
     * @param e The InternalFrameEvent.
     */
00090     public void internalFrameActivated(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }

    /**
     * This method is called when the JInternalFrame is closed.
     *
     * @param e The InternalFrameEvent.
     */
00100     public void internalFrameClosed(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }

    /**
     * This method is called when the JInternalFrame is closing.
     *
     * @param e The InternalFrameEvent.
     */
00110     public void internalFrameClosing(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }

    /**
     * This method is called when the JInternalFrame is deactivated.
     *
     * @param e The InternalFrameEvent.
     */
00120     public void internalFrameDeactivated(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }

    /**
     * This method is called when the JInternalFrame is  deiconified.
     *
     * @param e The InternalFrameEvent.
     */
00130     public void internalFrameDeiconified(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }

    /**
     * This method is called when the JInternalFrame is  iconified.
     *
     * @param e The InternalFrameEvent.
     */
00140     public void internalFrameIconified(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }

    /**
     * This method is called when the JInternalFrame is opened.
     *
     * @param e The InternalFrameEvent.
     */
00150     public void internalFrameOpened(InternalFrameEvent e)
    {
      // FIXME: Implement.
    }
  }

  /**
   * This helper class listens to the edges of the JInternalFrame and the
   * TitlePane for mouse events. It is responsible for dragging  and resizing
   * the JInternalFrame in response to the MouseEvents.
   */
00161   protected class BorderListener extends MouseInputAdapter
    implements SwingConstants
  {
    /** FIXME: Use for something. */
00165     protected int RESIZE_NONE;

    /** The x offset from the top left corner of the JInternalFrame. */
00168     private transient int xOffset = 0;

    /** The y offset from the top left corner of the JInternalFrame. */
00171     private transient int yOffset = 0;

    /** The direction that the resize is occuring in. */
00174     private transient int direction = -1;

    /** Cache rectangle that can be reused. */
00177     private transient Rectangle cacheRect = new Rectangle();

    /**
     * This method is called when the mouse is clicked.
     *
     * @param e The MouseEvent.
     */
00184     public void mouseClicked(MouseEvent e)
    {
      // There is nothing to do when the mouse is clicked
      // on the border.
    }

    /**
     * This method is called when the mouse is dragged. This method is
     * responsible for resizing or dragging the JInternalFrame.
     *
     * @param e The MouseEvent.
     */
00196     public void mouseDragged(MouseEvent e)
    {
      // If the frame is maximized, there is nothing that 
      // can be dragged around.
      if (frame.isMaximum())
      return;
      DesktopManager dm = getDesktopManager();
      Rectangle b = frame.getBounds();
      Dimension min = frame.getMinimumSize();
      if (min == null)
      min = new Dimension(0, 0);
      Insets insets = frame.getInsets();
      int x = e.getX();
      int y = e.getY();
      if (e.getSource() == frame && frame.isResizable())
        {
        switch (direction)
          {
          case NORTH:
            cacheRect.setBounds(b.x,
                                Math.min(b.y + y, b.y + b.height
                                         - min.height), b.width, b.height
                                - y);
            break;
          case NORTH_EAST:
            cacheRect.setBounds(b.x,
                                Math.min(b.y + y, b.y + b.height
                                         - min.height), x, b.height - y);
            break;
          case EAST:
            cacheRect.setBounds(b.x, b.y, x, b.height);
            break;
          case SOUTH_EAST:
            cacheRect.setBounds(b.x, b.y, x, y);
            break;
          case SOUTH:
            cacheRect.setBounds(b.x, b.y, b.width, y);
            break;
          case SOUTH_WEST:
            cacheRect.setBounds(Math.min(b.x + x, b.x + b.width - min.width),
                                b.y, b.width - x, y);
            break;
          case WEST:
            cacheRect.setBounds(Math.min(b.x + x, b.x + b.width - min.width),
                                b.y, b.width - x, b.height);
            break;
          case NORTH_WEST:
            cacheRect.setBounds(Math.min(b.x + x, b.x + b.width - min.width),
                                Math.min(b.y + y, b.y + b.height
                                         - min.height), b.width - x,
                                b.height - y);
            break;
          }
        dm.resizeFrame(frame, cacheRect.x, cacheRect.y,
                       Math.max(min.width, cacheRect.width),
                       Math.max(min.height, cacheRect.height));
        }
      else if (e.getSource() == titlePane)
        {
        Rectangle fBounds = frame.getBounds();

        dm.dragFrame(frame, e.getX() - xOffset + b.x,
                     e.getY() - yOffset + b.y);
        }
    }

    /**
     * This method is called when the mouse exits the JInternalFrame.
     *
     * @param e The MouseEvent.
     */
00267     public void mouseExited(MouseEvent e)
    {
      // There is nothing to do when the mouse exits 
      // the border area.
    }

    /**
     * This method is called when the mouse is moved inside the
     * JInternalFrame.
     *
     * @param e The MouseEvent.
     */
00279     public void mouseMoved(MouseEvent e)
    {
      // There is nothing to do when the mouse moves
      // over the border area.
    }

    /**
     * This method is called when the mouse is pressed.
     *
     * @param e The MouseEvent.
     */
00290     public void mousePressed(MouseEvent e)
    {
      activateFrame(frame);
      DesktopManager dm = getDesktopManager();
      int x = e.getX();
      int y = e.getY();
      Insets insets = frame.getInsets();

      if (e.getSource() == frame && frame.isResizable())
        {
        direction = sectionOfClick(x, y);
        dm.beginResizingFrame(frame, direction);
        }
      else if (e.getSource() == titlePane)
        {
        Rectangle tBounds = titlePane.getBounds();

        xOffset = e.getX() - tBounds.x + insets.left;
        yOffset = e.getY() - tBounds.y + insets.top;

        dm.beginDraggingFrame(frame);
        }
    }

    /**
     * This method is called when the mouse is released.
     *
     * @param e The MouseEvent.
     */
00319     public void mouseReleased(MouseEvent e)
    {
      DesktopManager dm = getDesktopManager();
      xOffset = 0;
      yOffset = 0;
      if (e.getSource() == frame && frame.isResizable())
      dm.endResizingFrame(frame);
      else if (e.getSource() == titlePane)
      dm.endDraggingFrame(frame);
    }

    /**
     * This method determines the direction of the resize based on the
     * coordinates and the size of the JInternalFrame.
     *
     * @param x The x coordinate of the MouseEvent.
     * @param y The y coordinate of the MouseEvent.
     *
     * @return The direction of the resize (a SwingConstant direction).
     */
00339     private int sectionOfClick(int x, int y)
    {
      Insets insets = frame.getInsets();
      Rectangle b = frame.getBounds();
      if (x < insets.left && y < insets.top)
      return NORTH_WEST;
      else if (x > b.width - insets.right && y < insets.top)
      return NORTH_EAST;
      else if (x > b.width - insets.right && y > b.height - insets.bottom)
      return SOUTH_EAST;
      else if (x < insets.left && y > b.height - insets.bottom)
      return SOUTH_WEST;
      else if (y < insets.top)
      return NORTH;
      else if (x < insets.left)
      return WEST;
      else if (y > b.height - insets.bottom)
      return SOUTH;
      else if (x > b.width - insets.right)
      return EAST;

      return -1;
    }
  }

  /**
   * This helper class listens to the JDesktopPane that parents this
   * JInternalFrame and listens for resize events and resizes the
   * JInternalFrame appropriately.
   */
00369   protected class ComponentHandler implements ComponentListener
  {
    /**
     * This method is called when the JDesktopPane is hidden.
     *
     * @param e The ComponentEvent fired.
     */
00376     public void componentHidden(ComponentEvent e)
    {
      // Do nothing.
    }

    /**
     * This method is called when the JDesktopPane is moved.
     *
     * @param e The ComponentEvent fired.
     */
00386     public void componentMoved(ComponentEvent e)
    {
      // Do nothing.
    }

    /**
     * This method is called when the JDesktopPane is resized.
     *
     * @param e The ComponentEvent fired.
     */
00396     public void componentResized(ComponentEvent e)
    {
      if (frame.isMaximum())
        {
        JDesktopPane pane = (JDesktopPane) e.getSource();
        Insets insets = pane.getInsets();
        Rectangle bounds = pane.getBounds();

        frame.setBounds(bounds.x + insets.left, bounds.y + insets.top,
                        bounds.width - insets.left - insets.right,
                        bounds.height - insets.top - insets.bottom);
        frame.revalidate();
        frame.repaint();
        }

      // Sun also resizes the icons. but it doesn't seem to do anything.
    }

    /**
     * This method is called when the JDesktopPane is shown.
     *
     * @param e The ComponentEvent fired.
     */
00419     public void componentShown(ComponentEvent e)
    {
      // Do nothing.
    }
  }

  /**
   * This helper class acts as the LayoutManager for JInternalFrames.
   */
00428   public class InternalFrameLayout implements LayoutManager
  {
    /**
     * This method is called when the given Component is added  to the
     * JInternalFrame.
     *
     * @param name The name of the Component.
     * @param c The Component added.
     */
00437     public void addLayoutComponent(String name, Component c)
    {
    }

    /**
     * This method is used to set the bounds of the children of the
     * JInternalFrame.
     *
     * @param c The Container to lay out.
     */
00447     public void layoutContainer(Container c)
    {
      Dimension dims = frame.getSize();
      Insets insets = frame.getInsets();

      dims.width -= insets.left + insets.right;
      dims.height -= insets.top + insets.bottom;

      frame.getRootPane().getGlassPane().setBounds(0, 0, dims.width,
                                                   dims.height);
      int nh = 0;
      int sh = 0;
      int ew = 0;
      int ww = 0;

      if (northPane != null)
        {
        Dimension nDims = northPane.getPreferredSize();
        nh = Math.min(nDims.height, dims.height);

        northPane.setBounds(insets.left, insets.top, dims.width, nh);
        }

      if (southPane != null)
        {
        Dimension sDims = southPane.getPreferredSize();
        sh = Math.min(sDims.height, dims.height - nh);

        southPane.setBounds(insets.left, insets.top + dims.height - sh,
                            dims.width, sh);
        }

      int remHeight = dims.height - sh - nh;

      if (westPane != null)
        {
        Dimension wDims = westPane.getPreferredSize();
        ww = Math.min(dims.width, wDims.width);

        westPane.setBounds(insets.left, insets.top + nh, ww, remHeight);
        }

      if (eastPane != null)
        {
        Dimension eDims = eastPane.getPreferredSize();
        ew = Math.min(eDims.width, dims.width - ww);

        eastPane.setBounds(insets.left + dims.width - ew, insets.top + nh,
                           ew, remHeight);
        }

      int remWidth = dims.width - ww - ew;

      frame.getRootPane().setBounds(insets.left + ww, insets.top + nh,
                                    remWidth, remHeight);
    }

    /**
     * This method returns the minimum layout size.
     *
     * @param c The Container to find a minimum layout size for.
     *
     * @return The minimum dimensions for the JInternalFrame.
     */
00511     public Dimension minimumLayoutSize(Container c)
    {
      return getSize(c, true);
    }

    /**
     * This method returns the maximum layout size.
     *
     * @param c The Container to find a maximum layout size for.
     *
     * @return The maximum dimensions for the JInternalFrame.
     */
00523     public Dimension maximumLayoutSize(Container c)
    {
      return preferredLayoutSize(c);
    }

    /**
     * Th8is method returns the preferred layout size.
     *
     * @param c The Container to find a preferred layout size for.
     *
     * @return The preferred dimensions for the JInternalFrame.
     */
00535     public Dimension preferredLayoutSize(Container c)
    {
      return getSize(c, false);
    }

    /**
     * DOCUMENT ME!
     *
     * @param c DOCUMENT ME!
     * @param min DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
00548     private Dimension getSize(Container c, boolean min)
    {
      Insets insets = frame.getInsets();

      Dimension contentDims = frame.getContentPane().getPreferredSize();
      if (min)
      contentDims.width = contentDims.height = 0;
      int nWidth = 0;
      int nHeight = 0;
      int sWidth = 0;
      int sHeight = 0;
      int eWidth = 0;
      int eHeight = 0;
      int wWidth = 0;
      int wHeight = 0;
      Dimension dims;

      if (northPane != null)
        {
        dims = northPane.getPreferredSize();
        if (dims != null)
          {
            nWidth = dims.width;
            nHeight = dims.height;
          }
        }

      if (southPane != null)
        {
        dims = southPane.getPreferredSize();
        if (dims != null)
          {
            sWidth = dims.width;
            sHeight = dims.height;
          }
        }

      if (eastPane != null)
        {
        dims = eastPane.getPreferredSize();
        if (dims != null)
          {
            sWidth = dims.width;
            sHeight = dims.height;
          }
        }

      if (westPane != null)
        {
        dims = westPane.getPreferredSize();
        if (dims != null)
          {
            wWidth = dims.width;
            wHeight = dims.height;
          }
        }

      int width = Math.max(sWidth, nWidth);
      width = Math.max(width, contentDims.width + eWidth + wWidth);

      int height = Math.max(eHeight, wHeight);
      height = Math.max(height, contentDims.height);
      height += nHeight + sHeight;

      width += insets.left + insets.right;
      height += insets.top + insets.bottom;

      return new Dimension(width, height);
    }

    /**
     * This method is called when a Component is removed from the
     * JInternalFrame.
     *
     * @param c The Component that was removed.
     */
00624     public void removeLayoutComponent(Component c)
    {
    }
  }

  /**
   * This helper class is used to listen to the JDesktopPane's glassPane for
   * MouseEvents. The JInternalFrame can then be selected if a click is
   * detected on its children.
   */
00634   protected class GlassPaneDispatcher implements MouseInputListener
  {
    /** The MouseEvent target. */
00637     private transient Component mouseEventTarget;

    /** The component pressed. */
00640     private transient Component pressedComponent;

    /** The last component entered. */
00643     private transient Component lastComponentEntered;

    /** The number of presses. */
00646     private transient int pressCount;

    /**
     * This method is called when the mouse enters the glass pane.
     *
     * @param e The MouseEvent.
     */
00653     public void mouseEntered(MouseEvent e)
    {
      handleEvent(e);
    }

    /**
     * This method is called when the mouse is clicked on the glass pane.
     *
     * @param e The MouseEvent.
     */
00663     public void mouseClicked(MouseEvent e)
    {
      handleEvent(e);
    }

    /**
     * This method is called when the mouse is dragged in the glass pane.
     *
     * @param e The MouseEvent.
     */
00673     public void mouseDragged(MouseEvent e)
    {
      handleEvent(e);
    }

    /**
     * This method is called when the mouse exits the glass pane.
     *
     * @param e The MouseEvent.
     */
00683     public void mouseExited(MouseEvent e)
    {
      handleEvent(e);
    }

    /**
     * This method is called when the mouse is moved in the glass pane.
     *
     * @param e The MouseEvent.
     */
00693     public void mouseMoved(MouseEvent e)
    {
      handleEvent(e);
    }

    /**
     * This method is called when the mouse is  pressed in the glass pane.
     *
     * @param e The MouseEvent.
     */
00703     public void mousePressed(MouseEvent e)
    {
      activateFrame(frame);
      handleEvent(e);
    }

    /**
     * This method is called when the mouse is  released in the glass pane.
     *
     * @param e The MouseEvent.
     */
00714     public void mouseReleased(MouseEvent e)
    {
      handleEvent(e);
    }

    /**
     * This method acquires a candidate component to dispatch the  MouseEvent
     * to.
     *
     * @param me The MouseEvent to acquire a component for.
     */
00725     private void acquireComponentForMouseEvent(MouseEvent me)
    {
      int x = me.getX();
      int y = me.getY();

      // Find the candidate which should receive this event.
      Component parent = frame.getContentPane();
      if (parent == null)
      return;
      Component candidate = null;
      Point p = me.getPoint();
      while (candidate == null && parent != null)
        {
        candidate = SwingUtilities.getDeepestComponentAt(parent, p.x, p.y);
        if (candidate == null)
          {
            p = SwingUtilities.convertPoint(parent, p.x, p.y,
                                            parent.getParent());
            parent = parent.getParent();
          }
        }

      // If the only candidate we found was the native container itself,
      // don't dispatch any event at all.  We only care about the lightweight
      // children here.
      if (candidate == frame.getContentPane())
      candidate = null;

      // If our candidate is new, inform the old target we're leaving.
      if (lastComponentEntered != null && lastComponentEntered.isShowing()
          && lastComponentEntered != candidate)
        {
        Point tp = SwingUtilities.convertPoint(frame.getContentPane(), x, y,
                                               lastComponentEntered);
        MouseEvent exited = new MouseEvent(lastComponentEntered,
                                           MouseEvent.MOUSE_EXITED,
                                           me.getWhen(), me.getModifiersEx(),
                                           tp.x, tp.y, me.getClickCount(),
                                           me.isPopupTrigger(),
                                           me.getButton());
        lastComponentEntered.dispatchEvent(exited);
        lastComponentEntered = null;
        }

      // If we have a candidate, maybe enter it.
      if (candidate != null)
        {
        mouseEventTarget = candidate;
        if (candidate.isLightweight() && candidate.isShowing()
            && candidate != frame.getContentPane()
            && candidate != lastComponentEntered)
          {
            lastComponentEntered = mouseEventTarget;
            Point cp = SwingUtilities.convertPoint(frame.getContentPane(),
                                                   x, y, lastComponentEntered);
            MouseEvent entered = new MouseEvent(lastComponentEntered,
                                                MouseEvent.MOUSE_ENTERED,
                                                me.getWhen(),
                                                me.getModifiersEx(), cp.x,
                                                cp.y, me.getClickCount(),
                                                me.isPopupTrigger(),
                                                me.getButton());
            lastComponentEntered.dispatchEvent(entered);
          }
        }

      if (me.getID() == MouseEvent.MOUSE_RELEASED
          || me.getID() == MouseEvent.MOUSE_PRESSED && pressCount > 0
          || me.getID() == MouseEvent.MOUSE_DRAGGED)
      // If any of the following events occur while a button is held down,
      // they should be dispatched to the same component to which the
      // original MOUSE_PRESSED event was dispatched:
      //   - MOUSE_RELEASED
      //   - MOUSE_PRESSED: another button pressed while the first is held down
      //   - MOUSE_DRAGGED
      mouseEventTarget = pressedComponent;
      else if (me.getID() == MouseEvent.MOUSE_CLICKED)
        {
        // Don't dispatch CLICKED events whose target is not the same as the
        // target for the original PRESSED event.
        if (candidate != pressedComponent)
          mouseEventTarget = null;
        else if (pressCount == 0)
          pressedComponent = null;
        }
    }

    /**
     * This is a helper method that dispatches the GlassPane MouseEvents to
     * the proper component.
     *
     * @param e The AWTEvent to be dispatched. Usually an instance of
     *        MouseEvent.
     */
00819     private void handleEvent(AWTEvent e)
    {
      if (e instanceof MouseEvent)
        {
        MouseEvent me = SwingUtilities.convertMouseEvent(frame.getRootPane()
                                                              .getGlassPane(),
                                                         (MouseEvent) e,
                                                         frame.getRootPane()
                                                              .getGlassPane());

        acquireComponentForMouseEvent(me);

        // Avoid dispatching ENTERED and EXITED events twice.
        if (mouseEventTarget != null && mouseEventTarget.isShowing()
            && e.getID() != MouseEvent.MOUSE_ENTERED
            && e.getID() != MouseEvent.MOUSE_EXITED)
          {
            MouseEvent newEvt = SwingUtilities.convertMouseEvent(frame
                                                                 .getContentPane(),
                                                                 me,
                                                                 mouseEventTarget);
            mouseEventTarget.dispatchEvent(newEvt);

            switch (e.getID())
              {
            case MouseEvent.MOUSE_PRESSED:
              if (pressCount++ == 0)
                pressedComponent = mouseEventTarget;
              break;
            case MouseEvent.MOUSE_RELEASED:
              // Clear our memory of the original PRESSED event, only if
              // we're not expecting a CLICKED event after this. If
              // there is a CLICKED event after this, it will do clean up.
              if (--pressCount == 0
                  && mouseEventTarget != pressedComponent)
                pressedComponent = null;
              break;
              }
          }
        }
    }
  }

  /**
   * This helper class listens for PropertyChangeEvents from the
   * JInternalFrame.
   */
00866   public class InternalFramePropertyChangeListener
    implements PropertyChangeListener
  {
    /**
     * This method is called when one of the JInternalFrame's properties
     * change.
     *
     * @param evt The PropertyChangeEvent.
     */
00875     public void propertyChange(PropertyChangeEvent evt)
    {
      if (evt.getPropertyName().equals(JInternalFrame.IS_MAXIMUM_PROPERTY))
        {
        if (frame.isMaximum())
          maximizeFrame(frame);
        else
          minimizeFrame(frame);
        }
      else if (evt.getPropertyName().equals(JInternalFrame.IS_CLOSED_PROPERTY))
      closeFrame(frame);
      else if (evt.getPropertyName().equals(JInternalFrame.IS_ICON_PROPERTY))
        {
        if (frame.isIcon())
          iconifyFrame(frame);
        else
          deiconifyFrame(frame);
        }
      else if (evt.getPropertyName().equals(JInternalFrame.IS_SELECTED_PROPERTY))
        {
        if (frame.isSelected())
          activateFrame(frame);
        else
          getDesktopManager().deactivateFrame(frame);
        }
      else if (evt.getPropertyName().equals(JInternalFrame.ROOT_PANE_PROPERTY)
               || evt.getPropertyName().equals(JInternalFrame.GLASS_PANE_PROPERTY))
        {
        Component old = (Component) evt.getOldValue();
        old.removeMouseListener(glassPaneDispatcher);
        old.removeMouseMotionListener(glassPaneDispatcher);

        Component newPane = (Component) evt.getNewValue();
        newPane.addMouseListener(glassPaneDispatcher);
        newPane.addMouseMotionListener(glassPaneDispatcher);

        frame.revalidate();
        }
      /* FIXME: need to add ancestor properties to JComponents.
      else if (evt.getPropertyName().equals(JComponent.ANCESTOR_PROPERTY))
      {
        if (desktopPane != null)
          desktopPane.removeComponentListener(componentListener);
        desktopPane = frame.getDesktopPane();
        if (desktopPane != null)
          desktopPane.addComponentListener(componentListener);
      }
      */
    }
  }

  /**
   * This helper class is the border for the JInternalFrame.
   */
00929   private class InternalFrameBorder extends AbstractBorder
    implements UIResource
  {
    /** The width of the border. */
00933     private static final int bSize = 5;

    /** The size of the corners. */
00936     private static final int offset = 10;

    /**
     * This method returns whether the border is opaque.
     *
     * @return Whether the border is opaque.
     */
00943     public boolean isBorderOpaque()
    {
      return true;
    }

    /**
     * This method returns the insets of the border.
     *
     * @param c The Component to find border insets for.
     *
     * @return The border insets.
     */
00955     public Insets getBorderInsets(Component c)
    {
      return new Insets(bSize, bSize, bSize, bSize);
    }

    /**
     * This method paints the border.
     *
     * @param c The Component that owns the border.
     * @param g The Graphics object to paint with.
     * @param x The x coordinate to paint at.
     * @param y The y coordinate to paint at.
     * @param width The width of the Component.
     * @param height The height of the Component.
     */
00970     public void paintBorder(Component c, Graphics g, int x, int y, int width,
                            int height)
    {
      g.translate(x, y);
      Color saved = g.getColor();
      Rectangle b = frame.getBounds();

      Color d = c.getBackground();
      g.setColor(d);
      g.fillRect(0, 0, bSize, b.height);
      g.fillRect(0, 0, b.width, bSize);
      g.fillRect(0, b.height - bSize, b.width, bSize);
      g.fillRect(b.width - bSize, 0, bSize, b.height);

      int x1 = 0;
      int x2 = bSize;
      int x3 = b.width - bSize;
      int x4 = b.width;

      int y1 = 0;
      int y2 = bSize;
      int y3 = b.height - bSize;
      int y4 = b.height;

      g.setColor(Color.GRAY);
      g.fillRect(0, 0, bSize, y4);
      g.fillRect(0, 0, x4, bSize);
      g.fillRect(0, y3, b.width, bSize);
      g.fillRect(x3, 0, bSize, b.height);

      g.fill3DRect(0, offset, bSize, b.height - 2 * offset, false);
      g.fill3DRect(offset, 0, b.width - 2 * offset, bSize, false);
      g.fill3DRect(offset, b.height - bSize, b.width - 2 * offset, bSize, false);
      g.fill3DRect(b.width - bSize, offset, bSize, b.height - 2 * offset, false);

      g.translate(-x, -y);
      g.setColor(saved);
    }
  }

  /**
   * The MouseListener that is responsible for dragging and resizing the
   * JInternalFrame in response to MouseEvents.
   */
01014   protected MouseInputAdapter borderListener;

  /**
   * The ComponentListener that is responsible for resizing the JInternalFrame
   * in response to ComponentEvents from the JDesktopPane.
   */
01020   protected ComponentListener componentListener;

  /**
   * The MouseListener that is responsible for activating the JInternalFrame
   * when the mouse press activates one of its descendents.
   */
01026   protected MouseInputListener glassPaneDispatcher;

  /**
   * The PropertyChangeListener that is responsible for listening to
   * PropertyChangeEvents from the JInternalFrame.
   */
01032   protected PropertyChangeListener propertyChangeListener;

  /** The InternalFrameListener that listens to the JInternalFrame. */
01035   private transient BasicInternalFrameListener internalFrameListener;

  /** The JComponent placed at the east region of the JInternalFrame. */
01038   protected JComponent eastPane;

  /** The JComponent placed at the north region of the JInternalFrame. */
01041   protected JComponent northPane;

  /** The JComponent placed at the south region of the JInternalFrame. */
01044   protected JComponent southPane;

  /** The JComponent placed at the west region of the JInternalFrame. */
01047   protected JComponent westPane;

  /**
   * The Keystroke bound to open the menu.
   * @deprecated
   */
01053   protected KeyStroke openMenuKey;

  /** The TitlePane displayed at the top of the JInternalFrame. */
01056   protected BasicInternalFrameTitlePane titlePane;

  /** The JInternalFrame this UI is responsible for. */
01059   protected JInternalFrame frame;

  /** The LayoutManager used in the JInternalFrame. */
01062   protected LayoutManager internalFrameLayout;

  /** The JDesktopPane that is the parent of the JInternalFrame. */
01065   private transient JDesktopPane desktopPane;

  /**
   * Creates a new BasicInternalFrameUI object.
   *
   * @param b The JInternalFrame this UI will represent.
   */
01072   public BasicInternalFrameUI(JInternalFrame b)
  {
  }

  /**
   * This method will create a new BasicInternalFrameUI for the given
   * JComponent.
   *
   * @param b The JComponent to create a BasicInternalFrameUI for.
   *
   * @return A new BasicInternalFrameUI.
   */
01084   public static ComponentUI createUI(JComponent b)
  {
    return new BasicInternalFrameUI((JInternalFrame) b);
  }

  /**
   * This method installs a UI for the JInternalFrame.
   *
   * @param c The JComponent to install this UI on.
   */
01094   public void installUI(JComponent c)
  {
    if (c instanceof JInternalFrame)
      {
      frame = (JInternalFrame) c;

      internalFrameLayout = createLayoutManager();
      frame.setLayout(internalFrameLayout);

      ((JComponent) frame.getRootPane().getGlassPane()).setOpaque(false);
      frame.getRootPane().getGlassPane().setVisible(true);

      installDefaults();
      installListeners();
      installComponents();
      installKeyboardActions();

      frame.setOpaque(true);
      titlePane.setOpaque(true);
      frame.invalidate();
      }
  }

  /**
   * This method reverses the work done by installUI.
   *
   * @param c The JComponent to uninstall this UI for.
   */
01122   public void uninstallUI(JComponent c)
  {
    uninstallKeyboardActions();
    uninstallComponents();
    uninstallListeners();
    uninstallDefaults();

    frame.setLayout(null);
    ((JComponent) frame.getRootPane().getGlassPane()).setOpaque(true);
    frame.getRootPane().getGlassPane().setVisible(false);

    frame = null;
  }

  /**
   * This method installs the defaults specified by the look and feel.
   */
01139   protected void installDefaults()
  {
    // FIXME: Move border to MetalBorders
    frame.setBorder(new InternalFrameBorder());
  }

  /**
   * This method installs the keyboard actions for the JInternalFrame.
   */
01148   protected void installKeyboardActions()
  {
    // FIXME: Implement.
  }

  /**
   * This method installs the Components for the JInternalFrame.
   */
01156   protected void installComponents()
  {
    setNorthPane(createNorthPane(frame));
    setSouthPane(createSouthPane(frame));
    setEastPane(createEastPane(frame));
    setWestPane(createWestPane(frame));
  }

  /**
   * This method installs the listeners for the JInternalFrame.
   */
01167   protected void installListeners()
  {
    glassPaneDispatcher = createGlassPaneDispatcher();
    createInternalFrameListener();
    borderListener = createBorderListener(frame);
    componentListener = createComponentListener();
    propertyChangeListener = createPropertyChangeListener();

    frame.addMouseListener(borderListener);
    frame.addMouseMotionListener(borderListener);
    frame.addInternalFrameListener(internalFrameListener);
    frame.addPropertyChangeListener(propertyChangeListener);

    frame.getRootPane().getGlassPane().addMouseListener(glassPaneDispatcher);
    frame.getRootPane().getGlassPane().addMouseMotionListener(glassPaneDispatcher);
  }

  /**
   * This method uninstalls the defaults for the JInternalFrame.
   */
01187   protected void uninstallDefaults()
  {
    frame.setBorder(null);
  }

  /**
   * This method uninstalls the Components for the JInternalFrame.
   */
01195   protected void uninstallComponents()
  {
    setNorthPane(null);
    setSouthPane(null);
    setEastPane(null);
    setWestPane(null);
  }

  /**
   * This method uninstalls the listeners for the JInternalFrame.
   */
01206   protected void uninstallListeners()
  {
    if (desktopPane != null)
      desktopPane.removeComponentListener(componentListener);

    frame.getRootPane().getGlassPane().removeMouseMotionListener(glassPaneDispatcher);
    frame.getRootPane().getGlassPane().removeMouseListener(glassPaneDispatcher);

    frame.removePropertyChangeListener(propertyChangeListener);
    frame.removeInternalFrameListener(internalFrameListener);
    frame.removeMouseMotionListener(borderListener);
    frame.removeMouseListener(borderListener);

    propertyChangeListener = null;
    componentListener = null;
    borderListener = null;
    internalFrameListener = null;
    glassPaneDispatcher = null;
  }

  /**
   * This method uninstalls the keyboard actions for the JInternalFrame.
   */
01229   protected void uninstallKeyboardActions()
  {
    // FIXME: Implement.
  }

  /**
   * This method creates a new LayoutManager for the JInternalFrame.
   *
   * @return A new LayoutManager for the JInternalFrame.
   */
01239   protected LayoutManager createLayoutManager()
  {
    return new InternalFrameLayout();
  }

  /**
   * This method creates a new PropertyChangeListener for the JInternalFrame.
   *
   * @return A new PropertyChangeListener for the JInternalFrame.
   */
01249   protected PropertyChangeListener createPropertyChangeListener()
  {
    return new InternalFramePropertyChangeListener();
  }

  /**
   * This method returns the preferred size of the given JComponent.
   *
   * @param x The JComponent to find a preferred size for.
   *
   * @return The preferred size.
   */
01261   public Dimension getPreferredSize(JComponent x)
  {
    return internalFrameLayout.preferredLayoutSize(x);
  }

  /**
   * This method returns the minimum size of the given JComponent.
   *
   * @param x The JComponent to find a minimum size for.
   *
   * @return The minimum size.
   */
01273   public Dimension getMinimumSize(JComponent x)
  {
    return internalFrameLayout.minimumLayoutSize(x);
  }

  /**
   * This method returns the maximum size of the given JComponent.
   *
   * @param x The JComponent to find a maximum size for.
   *
   * @return The maximum size.
   */
01285   public Dimension getMaximumSize(JComponent x)
  {
    return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  }

  /**
   * This method replaces the currentPane with the newPane. When replacing it
   * also removes the MouseHandlers for the old pane and installs  them on
   * the new pane.
   *
   * @param currentPane The old pane to remove.
   * @param newPane The new pane to install.
   */
01298   protected void replacePane(JComponent currentPane, JComponent newPane)
  {
    if (currentPane != null)
      {
      deinstallMouseHandlers(currentPane);
      frame.remove(currentPane);
      }

    if (newPane != null)
      {
      installMouseHandlers(newPane);
      frame.add(newPane);
      }
  }

  /**
   * This method removes the necessary MouseListeners from the given
   * JComponent.
   *
   * @param c The JComponent to remove MouseListeners from.
   */
01319   protected void deinstallMouseHandlers(JComponent c)
  {
    c.removeMouseListener(borderListener);
    c.removeMouseMotionListener(borderListener);
  }

  /**
   * This method installs the necessary MouseListeners from the given
   * JComponent.
   *
   * @param c The JComponent to install MouseListeners on.
   */
01331   protected void installMouseHandlers(JComponent c)
  {
    c.addMouseListener(borderListener);
    c.addMouseMotionListener(borderListener);
  }

  /**
   * This method creates the north pane used in the JInternalFrame.
   *
   * @param w The JInternalFrame to create a north pane for.
   *
   * @return The north pane.
   */
01344   protected JComponent createNorthPane(JInternalFrame w)
  {
    titlePane = new BasicInternalFrameTitlePane(w);
    return titlePane;
  }

  /**
   * This method creates the west pane used in the JInternalFrame.
   *
   * @param w The JInternalFrame to create a west pane for.
   *
   * @return The west pane.
   */
01357   protected JComponent createWestPane(JInternalFrame w)
  {
    return null;
  }

  /**
   * This method creates the south pane used in the JInternalFrame.
   *
   * @param w The JInternalFrame to create a south pane for.
   *
   * @return The south pane.
   */
01369   protected JComponent createSouthPane(JInternalFrame w)
  {
    return null;
  }

  /**
   * This method creates the east pane used in the JInternalFrame.
   *
   * @param w The JInternalFrame to create an east pane for.
   *
   * @return The east pane.
   */
01381   protected JComponent createEastPane(JInternalFrame w)
  {
    return null;
  }

  /**
   * This method returns a new BorderListener for the given JInternalFrame.
   *
   * @param w The JIntenalFrame to create a BorderListener for.
   *
   * @return A new BorderListener.
   */
01393   protected MouseInputAdapter createBorderListener(JInternalFrame w)
  {
    return new BorderListener();
  }

  /**
   * This method creates a new InternalFrameListener for the JInternalFrame.
   */
01401   protected void createInternalFrameListener()
  {
    internalFrameListener = new BasicInternalFrameListener();
  }

  /**
   * DOCUMENT ME!
   *
   * @return DOCUMENT ME!
   */
01411   protected final boolean isKeyBindingRegistered()
  {
    // FIXME: Implement.
    return false;
  }

  /**
   * DOCUMENT ME!
   *
   * @param b DOCUMENT ME!
   */
01422   protected final void setKeyBindingRegistered(boolean b)
  {
    // FIXME: Implement.
  }

  /**
   * DOCUMENT ME!
   *
   * @return DOCUMENT ME!
   */
01432   public final boolean isKeyBindingActive()
  {
    // FIXME: Implement.
    return false;
  }

  /**
   * DOCUMENT ME!
   *
   * @param b DOCUMENT ME!
   */
01443   protected final void setKeyBindingActive(boolean b)
  {
    // FIXME: Implement.
  }

  /**
   * DOCUMENT ME!
   */
01451   protected void setupMenuOpenKey()
  {
    // FIXME: Implement.
  }

  /**
   * DOCUMENT ME!
   */
01459   protected void setupMenuCloseKey()
  {
    // FIXME: Implement.
  }

  /**
   * This method returns the north pane.
   *
   * @return The north pane.
   */
01469   public JComponent getNorthPane()
  {
    return northPane;
  }

  /**
   * This method sets the north pane to be the given JComponent.
   *
   * @param c The new north pane.
   */
01479   public void setNorthPane(JComponent c)
  {
    replacePane(northPane, c);
    northPane = c;
  }

  /**
   * This method returns the south pane.
   *
   * @return The south pane.
   */
01490   public JComponent getSouthPane()
  {
    return southPane;
  }

  /**
   * This method sets the south pane to be the given JComponent.
   *
   * @param c The new south pane.
   */
01500   public void setSouthPane(JComponent c)
  {
    replacePane(southPane, c);
    southPane = c;
  }

  /**
   * This method sets the east pane to be the given JComponent.
   *
   * @param c The new east pane.
   */
01511   public void setEastPane(JComponent c)
  {
    replacePane(eastPane, c);
    eastPane = c;
  }

  /**
   * This method returns the east pane.
   *
   * @return The east pane.
   */
01522   public JComponent getEastPane()
  {
    return eastPane;
  }

  /**
   * This method sets the west pane to be the given JComponent.
   *
   * @param c The new west pane.
   */
01532   public void setWestPane(JComponent c)
  {
    replacePane(westPane, c);
    westPane = c;
  }

  /**
   * This method returns the west pane.
   *
   * @return The west pane.
   */
01543   public JComponent getWestPane()
  {
    return westPane;
  }

  /**
   * This method returns the DesktopManager to use with the JInternalFrame.
   *
   * @return The DesktopManager to use with the JInternalFrame.
   */
01553   protected DesktopManager getDesktopManager()
  {
    DesktopManager value = frame.getDesktopPane().getDesktopManager();
    if (value == null)
      value = createDesktopManager();
    return value;
  }

  /**
   * This method returns a default DesktopManager that can be used with this
   * JInternalFrame.
   *
   * @return A default DesktopManager that can be used with this
   *         JInternalFrame.
   */
01568   protected DesktopManager createDesktopManager()
  {
    return new DefaultDesktopManager();
  }

  /**
   * This is a convenience method that closes the JInternalFrame.
   *
   * @param f The JInternalFrame to close.
   */
01578   protected void closeFrame(JInternalFrame f)
  {
    getDesktopManager().closeFrame(f);
  }

  /**
   * This is a convenience method that maximizes the JInternalFrame.
   *
   * @param f The JInternalFrame to maximize.
   */
01588   protected void maximizeFrame(JInternalFrame f)
  {
    getDesktopManager().maximizeFrame(f);
  }

  /**
   * This is a convenience method that minimizes the JInternalFrame.
   *
   * @param f The JInternalFrame to minimize.
   */
01598   protected void minimizeFrame(JInternalFrame f)
  {
    getDesktopManager().minimizeFrame(f);
  }

  /**
   * This is a convenience method that iconifies the JInternalFrame.
   *
   * @param f The JInternalFrame to iconify.
   */
01608   protected void iconifyFrame(JInternalFrame f)
  {
    getDesktopManager().iconifyFrame(f);
  }

  /**
   * This is a convenience method that deiconifies the JInternalFrame.
   *
   * @param f The JInternalFrame to deiconify.
   */
01618   protected void deiconifyFrame(JInternalFrame f)
  {
    getDesktopManager().deiconifyFrame(f);
  }

  /**
   * This is a convenience method that activates the JInternalFrame.
   *
   * @param f The JInternalFrame to activate.
   */
01628   protected void activateFrame(JInternalFrame f)
  {
    getDesktopManager().activateFrame(f);
  }

  /**
   * This method returns a new ComponentListener for the JDesktopPane.
   *
   * @return A new ComponentListener.
   */
01638   protected ComponentListener createComponentListener()
  {
    return new ComponentHandler();
  }

  /**
   * This method returns a new GlassPaneDispatcher.
   *
   * @return A new GlassPaneDispatcher.
   */
01648   protected MouseInputListener createGlassPaneDispatcher()
  {
    return new GlassPaneDispatcher();
  }
}

Generated by  Doxygen 1.6.0   Back to index