mirror of git://gcc.gnu.org/git/gcc.git
1787 lines
48 KiB
Java
1787 lines
48 KiB
Java
/* BasicInternalFrameUI.java --
|
|
Copyright (C) 2004, 2005, 2006 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 javax.swing.plaf.basic;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.awt.Cursor;
|
|
import java.awt.Dimension;
|
|
import java.awt.Graphics;
|
|
import java.awt.Insets;
|
|
import java.awt.LayoutManager;
|
|
import java.awt.LayoutManager2;
|
|
import java.awt.Point;
|
|
import java.awt.Rectangle;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.ComponentEvent;
|
|
import java.awt.event.ComponentListener;
|
|
import java.awt.event.MouseEvent;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.beans.PropertyVetoException;
|
|
|
|
import javax.swing.AbstractAction;
|
|
import javax.swing.ActionMap;
|
|
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.LookAndFeel;
|
|
import javax.swing.SwingConstants;
|
|
import javax.swing.SwingUtilities;
|
|
import javax.swing.UIManager;
|
|
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.ActionMapUIResource;
|
|
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.
|
|
*/
|
|
public class BasicInternalFrameUI extends InternalFrameUI
|
|
{
|
|
/**
|
|
* This is a helper class that listens to the JInternalFrame for
|
|
* InternalFrameEvents.
|
|
*/
|
|
protected class BasicInternalFrameListener implements InternalFrameListener
|
|
{
|
|
/**
|
|
* This method is called when the JInternalFrame is activated.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
public void internalFrameActivated(InternalFrameEvent e)
|
|
{
|
|
frame.getGlassPane().setVisible(false);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JInternalFrame is closed.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
public void internalFrameClosed(InternalFrameEvent e)
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JInternalFrame is closing.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
public void internalFrameClosing(InternalFrameEvent e)
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JInternalFrame is deactivated.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
public void internalFrameDeactivated(InternalFrameEvent e)
|
|
{
|
|
frame.getGlassPane().setVisible(true);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JInternalFrame is deiconified.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
public void internalFrameDeiconified(InternalFrameEvent e)
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JInternalFrame is iconified.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
public void internalFrameIconified(InternalFrameEvent e)
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JInternalFrame is opened.
|
|
*
|
|
* @param e The InternalFrameEvent.
|
|
*/
|
|
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.
|
|
*/
|
|
protected class BorderListener extends MouseInputAdapter
|
|
implements SwingConstants
|
|
{
|
|
/**
|
|
* The current shape of the cursor.
|
|
*/
|
|
transient int showingCursor;
|
|
|
|
/** FIXME: Use for something. */
|
|
protected final int RESIZE_NONE = 0;
|
|
|
|
/** The x offset from the top left corner of the JInternalFrame. */
|
|
private transient int xOffset;
|
|
|
|
/** The y offset from the top left corner of the JInternalFrame. */
|
|
private transient int yOffset;
|
|
|
|
/** The direction that the resize is occuring in. */
|
|
private transient int direction = -1;
|
|
|
|
/** Cache rectangle that can be reused. */
|
|
private transient Rectangle cacheRect = new Rectangle();
|
|
|
|
/**
|
|
* This method is called when the mouse is clicked.
|
|
*
|
|
* @param e The MouseEvent.
|
|
*/
|
|
public void mouseClicked(MouseEvent e)
|
|
{
|
|
// Do minimization/maximization when double-clicking in the title pane.
|
|
if (e.getSource() == titlePane && e.getClickCount() == 2)
|
|
try
|
|
{
|
|
if (frame.isMaximizable() && ! frame.isMaximum())
|
|
frame.setMaximum(true);
|
|
else if (frame.isMaximum())
|
|
frame.setMaximum(false);
|
|
}
|
|
catch (PropertyVetoException pve)
|
|
{
|
|
// We do nothing if the attempt has been vetoed.
|
|
}
|
|
|
|
// 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.
|
|
*/
|
|
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 Cursor.N_RESIZE_CURSOR:
|
|
cacheRect.setBounds(b.x, Math.min(b.y + y, b.y + b.height
|
|
- min.height),
|
|
b.width, b.height - y);
|
|
break;
|
|
case Cursor.NE_RESIZE_CURSOR:
|
|
cacheRect.setBounds(b.x, Math.min(b.y + y, b.y + b.height
|
|
- min.height), x + 1,
|
|
b.height - y);
|
|
break;
|
|
case Cursor.E_RESIZE_CURSOR:
|
|
cacheRect.setBounds(b.x, b.y, x + 1, b.height);
|
|
break;
|
|
case Cursor.SE_RESIZE_CURSOR:
|
|
cacheRect.setBounds(b.x, b.y, x + 1, y + 1);
|
|
break;
|
|
case Cursor.S_RESIZE_CURSOR:
|
|
cacheRect.setBounds(b.x, b.y, b.width, y + 1);
|
|
break;
|
|
case Cursor.SW_RESIZE_CURSOR:
|
|
cacheRect.setBounds(Math.min(b.x + x, b.x + b.width - min.width),
|
|
b.y, b.width - x, y + 1);
|
|
break;
|
|
case Cursor.W_RESIZE_CURSOR:
|
|
cacheRect.setBounds(Math.min(b.x + x, b.x + b.width - min.width),
|
|
b.y, b.width - x, b.height);
|
|
break;
|
|
case Cursor.NW_RESIZE_CURSOR:
|
|
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));
|
|
setCursor(e);
|
|
}
|
|
else if (e.getSource() == titlePane)
|
|
{
|
|
Rectangle fBounds = frame.getBounds();
|
|
frame.putClientProperty("bufferedDragging", Boolean.TRUE);
|
|
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.
|
|
*/
|
|
public void mouseExited(MouseEvent e)
|
|
{
|
|
if (showingCursor != Cursor.DEFAULT_CURSOR)
|
|
{
|
|
frame.setCursor(Cursor.getDefaultCursor());
|
|
showingCursor = Cursor.DEFAULT_CURSOR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is moved inside the JInternalFrame.
|
|
*
|
|
* @param e The MouseEvent.
|
|
*/
|
|
public void mouseMoved(MouseEvent e)
|
|
{
|
|
// Turn off the resize cursor if we are in the frame header.
|
|
if (showingCursor != Cursor.DEFAULT_CURSOR && e.getSource() != frame)
|
|
{
|
|
frame.setCursor(Cursor.getDefaultCursor());
|
|
showingCursor = Cursor.DEFAULT_CURSOR;
|
|
}
|
|
else if (e.getSource() == frame && frame.isResizable())
|
|
{
|
|
setCursor(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the mouse cursor, how applicable.
|
|
*
|
|
* @param e the current mouse event.
|
|
*/
|
|
void setCursor(MouseEvent e)
|
|
{
|
|
int cursor = sectionOfClick(e.getX(), e.getY());
|
|
if (cursor != showingCursor)
|
|
{
|
|
Cursor resize = Cursor.getPredefinedCursor(cursor);
|
|
frame.setCursor(resize);
|
|
showingCursor = cursor;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is pressed.
|
|
*
|
|
* @param e The MouseEvent.
|
|
*/
|
|
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.
|
|
*/
|
|
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);
|
|
frame.putClientProperty("bufferedDragging", null);
|
|
}
|
|
|
|
setCursor(e);
|
|
}
|
|
|
|
/**
|
|
* 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 cursor constant, determining the resizing direction.
|
|
*/
|
|
private int sectionOfClick(int x, int y)
|
|
{
|
|
Rectangle b = frame.getBounds();
|
|
int corner = InternalFrameBorder.cornerSize;
|
|
|
|
if (x < corner && y < corner)
|
|
return Cursor.NW_RESIZE_CURSOR;
|
|
else if (x > b.width - corner && y < corner)
|
|
return Cursor.NE_RESIZE_CURSOR;
|
|
else if (x > b.width - corner && y > b.height - corner)
|
|
return Cursor.SE_RESIZE_CURSOR;
|
|
else if (x < corner && y > b.height - corner)
|
|
return Cursor.SW_RESIZE_CURSOR;
|
|
else if (y < corner)
|
|
return Cursor.N_RESIZE_CURSOR;
|
|
else if (x < corner)
|
|
return Cursor.W_RESIZE_CURSOR;
|
|
else if (y > b.height - corner)
|
|
return Cursor.S_RESIZE_CURSOR;
|
|
else if (x > b.width - corner)
|
|
return Cursor.E_RESIZE_CURSOR;
|
|
|
|
return Cursor.DEFAULT_CURSOR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This helper class listens to the JDesktopPane that parents this
|
|
* JInternalFrame and listens for resize events and resizes the
|
|
* JInternalFrame appropriately.
|
|
*/
|
|
protected class ComponentHandler implements ComponentListener
|
|
{
|
|
/**
|
|
* This method is called when the JDesktopPane is hidden.
|
|
*
|
|
* @param e
|
|
* The ComponentEvent fired.
|
|
*/
|
|
public void componentHidden(ComponentEvent e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JDesktopPane is moved.
|
|
*
|
|
* @param e
|
|
* The ComponentEvent fired.
|
|
*/
|
|
public void componentMoved(ComponentEvent e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JDesktopPane is resized.
|
|
*
|
|
* @param e
|
|
* The ComponentEvent fired.
|
|
*/
|
|
public void componentResized(ComponentEvent e)
|
|
{
|
|
if (frame.isMaximum())
|
|
{
|
|
Container parent = frame.getParent();
|
|
Insets i = parent.getInsets();
|
|
int width = parent.getWidth() - i.left - i.right;
|
|
int height = parent.getHeight() - i.top - i.bottom;
|
|
frame.setBounds(0, 0, width, height);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JDesktopPane is shown.
|
|
*
|
|
* @param e
|
|
* The ComponentEvent fired.
|
|
*/
|
|
public void componentShown(ComponentEvent e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This helper class acts as the LayoutManager for JInternalFrames.
|
|
*/
|
|
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.
|
|
*/
|
|
public void addLayoutComponent(String name, Component c)
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* This method is used to set the bounds of the children of the
|
|
* JInternalFrame.
|
|
*
|
|
* @param c
|
|
* The Container to lay out.
|
|
*/
|
|
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;
|
|
|
|
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.
|
|
*/
|
|
public Dimension minimumLayoutSize(Container c)
|
|
{
|
|
return getSize(c, true);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
public Dimension preferredLayoutSize(Container c)
|
|
{
|
|
return getSize(c, false);
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @param c
|
|
* DOCUMENT ME!
|
|
* @param min
|
|
* DOCUMENT ME!
|
|
* @return DOCUMENT ME!
|
|
*/
|
|
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.
|
|
*/
|
|
public void removeLayoutComponent(Component c)
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
protected class GlassPaneDispatcher implements MouseInputListener
|
|
{
|
|
/** The MouseEvent target. */
|
|
private transient Component mouseEventTarget;
|
|
|
|
private Component dragTarget;
|
|
|
|
/**
|
|
* Indicates if we are currently in a dragging operation or not.
|
|
*/
|
|
private boolean isDragging;
|
|
|
|
/**
|
|
* This method is called when the mouse enters the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mouseEntered(MouseEvent e)
|
|
{
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is clicked on the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mouseClicked(MouseEvent e)
|
|
{
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is dragged in the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mouseDragged(MouseEvent e)
|
|
{
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse exits the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mouseExited(MouseEvent e)
|
|
{
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is moved in the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mouseMoved(MouseEvent e)
|
|
{
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is pressed in the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mousePressed(MouseEvent e)
|
|
{
|
|
// Experiments show that this seems to call the
|
|
// borderListener.mousePressed() method to activate the frame.
|
|
if (borderListener != null)
|
|
borderListener.mousePressed(e);
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This method is called when the mouse is released in the glass pane.
|
|
*
|
|
* @param e
|
|
* The MouseEvent.
|
|
*/
|
|
public void mouseReleased(MouseEvent e)
|
|
{
|
|
handleEvent(e);
|
|
}
|
|
|
|
/**
|
|
* This is a helper method that dispatches the GlassPane MouseEvents to the
|
|
* proper component.
|
|
*
|
|
* @param e the mouse event to be dispatched
|
|
*/
|
|
private void handleEvent(MouseEvent e)
|
|
{
|
|
// Find candidate component inside the JInternalFrame.
|
|
Component target = frame.getLayeredPane().findComponentAt(e.getX(),
|
|
e.getY());
|
|
|
|
// Now search upwards to find a component that actually has
|
|
// a MouseListener attached.
|
|
while (target != null
|
|
&& target.getMouseListeners().length == 0
|
|
&& target.getMouseMotionListeners().length == 0
|
|
&& target.getMouseWheelListeners().length == 0)
|
|
{
|
|
target = target.getParent();
|
|
}
|
|
|
|
if (target != null)
|
|
{
|
|
int id = e.getID();
|
|
switch (id)
|
|
{
|
|
case MouseEvent.MOUSE_ENTERED:
|
|
// Now redispatch the thing.
|
|
if (! isDragging || frame.isSelected())
|
|
{
|
|
mouseEventTarget = target;
|
|
redispatch(id, e, mouseEventTarget);
|
|
}
|
|
break;
|
|
case MouseEvent.MOUSE_EXITED:
|
|
if (! isDragging || frame.isSelected())
|
|
{
|
|
redispatch(id, e, mouseEventTarget);
|
|
}
|
|
break;
|
|
case MouseEvent.MOUSE_PRESSED:
|
|
mouseEventTarget = target;
|
|
redispatch(id, e, mouseEventTarget);
|
|
// Start dragging.
|
|
dragTarget = target;
|
|
break;
|
|
case MouseEvent.MOUSE_RELEASED:
|
|
if (isDragging)
|
|
{
|
|
redispatch(id, e, dragTarget);
|
|
isDragging = false;
|
|
}
|
|
else
|
|
redispatch(id, e, mouseEventTarget);
|
|
break;
|
|
case MouseEvent.MOUSE_CLICKED:
|
|
redispatch(id, e, mouseEventTarget);
|
|
break;
|
|
case MouseEvent.MOUSE_MOVED:
|
|
if (target != mouseEventTarget)
|
|
{
|
|
// Create additional MOUSE_EXITED/MOUSE_ENTERED pairs.
|
|
redispatch(MouseEvent.MOUSE_EXITED, e, mouseEventTarget);
|
|
mouseEventTarget = target;
|
|
redispatch(MouseEvent.MOUSE_ENTERED, e, mouseEventTarget);
|
|
}
|
|
redispatch(id, e, mouseEventTarget);
|
|
break;
|
|
case MouseEvent.MOUSE_DRAGGED:
|
|
if (! isDragging)
|
|
isDragging = true;
|
|
redispatch(id, e, mouseEventTarget);
|
|
break;
|
|
case MouseEvent.MOUSE_WHEEL:
|
|
redispatch(id, e, mouseEventTarget);
|
|
break;
|
|
default:
|
|
assert false : "Must not reach here";
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Redispatches the event to the real target with the specified id.
|
|
*
|
|
* @param id the new event ID
|
|
* @param e the original event
|
|
* @param target the real event target
|
|
*/
|
|
private void redispatch(int id, MouseEvent e, Component target)
|
|
{
|
|
Point p = SwingUtilities.convertPoint(frame.getLayeredPane(), e.getX(),
|
|
e.getY(), target);
|
|
MouseEvent ev = new MouseEvent(target, id, e.getWhen(),
|
|
e.getModifiers() | e.getModifiersEx(),
|
|
p.x, p.y, e.getClickCount(),
|
|
e.isPopupTrigger());
|
|
target.dispatchEvent(ev);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This helper class listens for PropertyChangeEvents from the
|
|
* JInternalFrame.
|
|
*/
|
|
public class InternalFramePropertyChangeListener
|
|
implements PropertyChangeListener
|
|
{
|
|
|
|
/**
|
|
* This method is called when one of the JInternalFrame's properties change.
|
|
*
|
|
* @param evt
|
|
* The PropertyChangeEvent.
|
|
*/
|
|
public void propertyChange(PropertyChangeEvent evt)
|
|
{
|
|
String property = evt.getPropertyName();
|
|
if (property.equals(JInternalFrame.IS_MAXIMUM_PROPERTY))
|
|
{
|
|
if (frame.isMaximum())
|
|
maximizeFrame(frame);
|
|
else
|
|
minimizeFrame(frame);
|
|
}
|
|
else if (property.equals(JInternalFrame.IS_ICON_PROPERTY))
|
|
{
|
|
if (frame.isIcon())
|
|
iconifyFrame(frame);
|
|
else
|
|
deiconifyFrame(frame);
|
|
}
|
|
else if (property.equals(JInternalFrame.IS_SELECTED_PROPERTY))
|
|
{
|
|
Component glassPane = frame.getGlassPane();
|
|
if (frame.isSelected())
|
|
{
|
|
activateFrame(frame);
|
|
glassPane.setVisible(false);
|
|
}
|
|
else
|
|
{
|
|
deactivateFrame(frame);
|
|
glassPane.setVisible(true);
|
|
}
|
|
}
|
|
else if (property.equals(JInternalFrame.ROOT_PANE_PROPERTY)
|
|
|| property.equals(JInternalFrame.GLASS_PANE_PROPERTY))
|
|
{
|
|
Component old = (Component) evt.getOldValue();
|
|
if (old != null)
|
|
{
|
|
old.removeMouseListener(glassPaneDispatcher);
|
|
old.removeMouseMotionListener(glassPaneDispatcher);
|
|
}
|
|
|
|
Component newPane = (Component) evt.getNewValue();
|
|
if (newPane != null)
|
|
{
|
|
newPane.addMouseListener(glassPaneDispatcher);
|
|
newPane.addMouseMotionListener(glassPaneDispatcher);
|
|
}
|
|
|
|
frame.revalidate();
|
|
}
|
|
else if (property.equals(JInternalFrame.IS_CLOSED_PROPERTY))
|
|
{
|
|
if (evt.getNewValue() == Boolean.TRUE)
|
|
{
|
|
Container parent = frame.getParent();
|
|
if (parent != null)
|
|
parent.removeComponentListener(componentListener);
|
|
closeFrame(frame);
|
|
}
|
|
}
|
|
else if (property.equals("ancestor"))
|
|
{
|
|
Container newParent = (Container) evt.getNewValue();
|
|
Container oldParent = (Container) evt.getOldValue();
|
|
if (newParent != null)
|
|
{
|
|
newParent.addComponentListener(componentListener);
|
|
}
|
|
else if (oldParent != null)
|
|
{
|
|
oldParent.removeComponentListener(componentListener);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This helper class is the border for the JInternalFrame.
|
|
*/
|
|
class InternalFrameBorder extends AbstractBorder implements
|
|
UIResource
|
|
{
|
|
/**
|
|
* The width of the border.
|
|
*/
|
|
static final int bSize = 5;
|
|
|
|
/**
|
|
* The size of the corners (also used by the mouse listener).
|
|
*/
|
|
static final int cornerSize = 10;
|
|
|
|
/**
|
|
* This method returns whether the border is opaque.
|
|
*
|
|
* @return Whether the border is opaque.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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, cornerSize, bSize, b.height - 2 * cornerSize, false);
|
|
g.fill3DRect(cornerSize, 0, b.width - 2 * cornerSize, bSize, false);
|
|
g.fill3DRect(cornerSize, b.height - bSize, b.width - 2 * cornerSize,
|
|
bSize, false);
|
|
g.fill3DRect(b.width - bSize, cornerSize, bSize,
|
|
b.height - 2 * cornerSize, false);
|
|
|
|
g.translate(-x, -y);
|
|
g.setColor(saved);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This action triggers the system menu.
|
|
*
|
|
* @author Roman Kennke (kennke@aicas.com)
|
|
*/
|
|
private class ShowSystemMenuAction
|
|
extends AbstractAction
|
|
{
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
if (titlePane != null)
|
|
{
|
|
titlePane.showSystemMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The MouseListener that is responsible for dragging and resizing the
|
|
* JInternalFrame in response to MouseEvents.
|
|
*/
|
|
protected MouseInputAdapter borderListener;
|
|
|
|
/**
|
|
* The ComponentListener that is responsible for resizing the JInternalFrame
|
|
* in response to ComponentEvents from the JDesktopPane.
|
|
*/
|
|
protected ComponentListener componentListener;
|
|
|
|
/**
|
|
* The MouseListener that is responsible for activating the JInternalFrame
|
|
* when the mouse press activates one of its descendents.
|
|
*/
|
|
protected MouseInputListener glassPaneDispatcher;
|
|
|
|
/**
|
|
* The PropertyChangeListener that is responsible for listening to
|
|
* PropertyChangeEvents from the JInternalFrame.
|
|
*/
|
|
protected PropertyChangeListener propertyChangeListener;
|
|
|
|
/** The InternalFrameListener that listens to the JInternalFrame. */
|
|
private transient BasicInternalFrameListener internalFrameListener;
|
|
|
|
/** The JComponent placed at the east region of the JInternalFrame. */
|
|
protected JComponent eastPane;
|
|
|
|
/** The JComponent placed at the north region of the JInternalFrame. */
|
|
protected JComponent northPane;
|
|
|
|
/** The JComponent placed at the south region of the JInternalFrame. */
|
|
protected JComponent southPane;
|
|
|
|
/** The JComponent placed at the west region of the JInternalFrame. */
|
|
protected JComponent westPane;
|
|
|
|
/**
|
|
* The Keystroke bound to open the menu.
|
|
* @deprecated
|
|
*/
|
|
protected KeyStroke openMenuKey;
|
|
|
|
/** The TitlePane displayed at the top of the JInternalFrame. */
|
|
protected BasicInternalFrameTitlePane titlePane;
|
|
|
|
/** The JInternalFrame this UI is responsible for. */
|
|
protected JInternalFrame frame;
|
|
|
|
/** The LayoutManager used in the JInternalFrame. */
|
|
protected LayoutManager internalFrameLayout;
|
|
|
|
/** The JDesktopPane that is the parent of the JInternalFrame. */
|
|
private transient JDesktopPane desktopPane;
|
|
|
|
/**
|
|
* Creates a new BasicInternalFrameUI object.
|
|
*
|
|
* @param b The JInternalFrame this UI will represent.
|
|
*/
|
|
public BasicInternalFrameUI(JInternalFrame b)
|
|
{
|
|
// Nothing to do here.
|
|
}
|
|
|
|
/**
|
|
* This method will create a new BasicInternalFrameUI for the given
|
|
* JComponent.
|
|
*
|
|
* @param b The JComponent to create a BasicInternalFrameUI for.
|
|
*
|
|
* @return A new BasicInternalFrameUI.
|
|
*/
|
|
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.
|
|
*/
|
|
public void installUI(JComponent c)
|
|
{
|
|
if (c instanceof JInternalFrame)
|
|
{
|
|
frame = (JInternalFrame) c;
|
|
|
|
installDefaults();
|
|
installListeners();
|
|
installComponents();
|
|
installKeyboardActions();
|
|
|
|
if (! frame.isSelected())
|
|
frame.getGlassPane().setVisible(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method reverses the work done by installUI.
|
|
*
|
|
* @param c The JComponent to uninstall this UI for.
|
|
*/
|
|
public void uninstallUI(JComponent c)
|
|
{
|
|
uninstallKeyboardActions();
|
|
uninstallComponents();
|
|
uninstallListeners();
|
|
uninstallDefaults();
|
|
|
|
frame.getRootPane().getGlassPane().setVisible(false);
|
|
frame = null;
|
|
}
|
|
|
|
/**
|
|
* This method installs the defaults specified by the look and feel.
|
|
*/
|
|
protected void installDefaults()
|
|
{
|
|
internalFrameLayout = createLayoutManager();
|
|
frame.setLayout(internalFrameLayout);
|
|
LookAndFeel.installBorder(frame, "InternalFrame.border");
|
|
frame.setFrameIcon(UIManager.getIcon("InternalFrame.icon"));
|
|
|
|
// Let the content pane inherit the background color from its
|
|
// frame by setting the background to null.
|
|
Component contentPane = frame.getContentPane();
|
|
if (contentPane != null
|
|
&& contentPane.getBackground() instanceof UIResource)
|
|
{
|
|
contentPane.setBackground(null);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method installs the keyboard actions for the JInternalFrame.
|
|
*/
|
|
protected void installKeyboardActions()
|
|
{
|
|
ActionMapUIResource am = new ActionMapUIResource();
|
|
am.put("showSystemMenu", new ShowSystemMenuAction());
|
|
|
|
// The RI impl installs the audio actions as parent of the UI action map,
|
|
// so do we.
|
|
BasicLookAndFeel blaf = (BasicLookAndFeel) UIManager.getLookAndFeel();
|
|
ActionMap audioActionMap = blaf.getAudioActionMap();
|
|
am.setParent(audioActionMap);
|
|
|
|
SwingUtilities.replaceUIActionMap(frame, am);
|
|
}
|
|
|
|
/**
|
|
* This method installs the Components for the JInternalFrame.
|
|
*/
|
|
protected void installComponents()
|
|
{
|
|
setNorthPane(createNorthPane(frame));
|
|
setSouthPane(createSouthPane(frame));
|
|
setEastPane(createEastPane(frame));
|
|
setWestPane(createWestPane(frame));
|
|
}
|
|
|
|
/**
|
|
* This method installs the listeners for the JInternalFrame.
|
|
*/
|
|
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);
|
|
|
|
Container parent = frame.getParent();
|
|
if (parent != null)
|
|
{
|
|
parent.addComponentListener(componentListener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the defaults for the JInternalFrame.
|
|
*/
|
|
protected void uninstallDefaults()
|
|
{
|
|
frame.setBorder(null);
|
|
frame.setLayout(null);
|
|
internalFrameLayout = null;
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the Components for the JInternalFrame.
|
|
*/
|
|
protected void uninstallComponents()
|
|
{
|
|
setNorthPane(null);
|
|
setSouthPane(null);
|
|
setEastPane(null);
|
|
setWestPane(null);
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the listeners for the JInternalFrame.
|
|
*/
|
|
protected void uninstallListeners()
|
|
{
|
|
|
|
Container parent = frame.getParent();
|
|
if (parent != null)
|
|
{
|
|
parent.removeComponentListener(componentListener);
|
|
}
|
|
componentListener = null;
|
|
|
|
frame.getRootPane().getGlassPane().removeMouseMotionListener(glassPaneDispatcher);
|
|
frame.getRootPane().getGlassPane().removeMouseListener(glassPaneDispatcher);
|
|
|
|
frame.removePropertyChangeListener(propertyChangeListener);
|
|
frame.removeInternalFrameListener(internalFrameListener);
|
|
frame.removeMouseMotionListener(borderListener);
|
|
frame.removeMouseListener(borderListener);
|
|
|
|
propertyChangeListener = null;
|
|
|
|
borderListener = null;
|
|
internalFrameListener = null;
|
|
glassPaneDispatcher = null;
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the keyboard actions for the JInternalFrame.
|
|
*/
|
|
protected void uninstallKeyboardActions()
|
|
{
|
|
SwingUtilities.replaceUIActionMap(frame, null);
|
|
SwingUtilities.replaceUIInputMap(frame, JComponent.WHEN_IN_FOCUSED_WINDOW,
|
|
null);
|
|
}
|
|
|
|
/**
|
|
* This method creates a new LayoutManager for the JInternalFrame.
|
|
*
|
|
* @return A new LayoutManager for the JInternalFrame.
|
|
*/
|
|
protected LayoutManager createLayoutManager()
|
|
{
|
|
return new InternalFrameLayout();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new PropertyChangeListener for the JInternalFrame.
|
|
*
|
|
* @return A new PropertyChangeListener for the JInternalFrame.
|
|
*/
|
|
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.
|
|
*/
|
|
public Dimension getPreferredSize(JComponent x)
|
|
{
|
|
Dimension pref = null;
|
|
LayoutManager layout = frame.getLayout();
|
|
if (frame == x && layout != null)
|
|
pref = layout.preferredLayoutSize(frame);
|
|
else
|
|
pref = new Dimension(100, 100);
|
|
return pref;
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum size of the given JComponent.
|
|
*
|
|
* @param x The JComponent to find a minimum size for.
|
|
*
|
|
* @return The minimum size.
|
|
*/
|
|
public Dimension getMinimumSize(JComponent x)
|
|
{
|
|
Dimension min = null;
|
|
LayoutManager layout = frame.getLayout();
|
|
if (frame == x && layout != null)
|
|
min = layout.minimumLayoutSize(frame);
|
|
else
|
|
min = new Dimension(0, 0);
|
|
return min;
|
|
}
|
|
|
|
/**
|
|
* This method returns the maximum size of the given JComponent.
|
|
*
|
|
* @param x The JComponent to find a maximum size for.
|
|
*
|
|
* @return The maximum size.
|
|
*/
|
|
public Dimension getMaximumSize(JComponent x)
|
|
{
|
|
Dimension max = null;
|
|
LayoutManager layout = frame.getLayout();
|
|
if (frame == x && layout != null && layout instanceof LayoutManager2)
|
|
max = ((LayoutManager2) layout).maximumLayoutSize(frame);
|
|
else
|
|
max = new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
|
return max;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
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.
|
|
*/
|
|
protected MouseInputAdapter createBorderListener(JInternalFrame w)
|
|
{
|
|
return new BorderListener();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new InternalFrameListener for the JInternalFrame.
|
|
*/
|
|
protected void createInternalFrameListener()
|
|
{
|
|
internalFrameListener = new BasicInternalFrameListener();
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @return DOCUMENT ME!
|
|
*/
|
|
protected final boolean isKeyBindingRegistered()
|
|
{
|
|
// FIXME: Implement.
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @param b DOCUMENT ME!
|
|
*/
|
|
protected final void setKeyBindingRegistered(boolean b)
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @return DOCUMENT ME!
|
|
*/
|
|
public final boolean isKeyBindingActive()
|
|
{
|
|
// FIXME: Implement.
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @param b DOCUMENT ME!
|
|
*/
|
|
protected final void setKeyBindingActive(boolean b)
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*/
|
|
protected void setupMenuOpenKey()
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*/
|
|
protected void setupMenuCloseKey()
|
|
{
|
|
// FIXME: Implement.
|
|
}
|
|
|
|
/**
|
|
* This method returns the north pane.
|
|
*
|
|
* @return The north pane.
|
|
*/
|
|
public JComponent getNorthPane()
|
|
{
|
|
return northPane;
|
|
}
|
|
|
|
/**
|
|
* This method sets the north pane to be the given JComponent.
|
|
*
|
|
* @param c The new north pane.
|
|
*/
|
|
public void setNorthPane(JComponent c)
|
|
{
|
|
replacePane(northPane, c);
|
|
northPane = c;
|
|
// the following is needed to make internal frames draggable when using
|
|
// the JGoodies PlasticLookAndFeel, because it overrides the
|
|
// createNorthPane() method and doesn't assign anything to the titlePane
|
|
// field. It is possible there is another way to make this work, but
|
|
// I didn't find it...
|
|
if (c instanceof BasicInternalFrameTitlePane)
|
|
titlePane = (BasicInternalFrameTitlePane) c;
|
|
}
|
|
|
|
/**
|
|
* This method returns the south pane.
|
|
*
|
|
* @return The south pane.
|
|
*/
|
|
public JComponent getSouthPane()
|
|
{
|
|
return southPane;
|
|
}
|
|
|
|
/**
|
|
* This method sets the south pane to be the given JComponent.
|
|
*
|
|
* @param c The new south pane.
|
|
*/
|
|
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.
|
|
*/
|
|
public void setEastPane(JComponent c)
|
|
{
|
|
replacePane(eastPane, c);
|
|
eastPane = c;
|
|
}
|
|
|
|
/**
|
|
* This method returns the east pane.
|
|
*
|
|
* @return The east pane.
|
|
*/
|
|
public JComponent getEastPane()
|
|
{
|
|
return eastPane;
|
|
}
|
|
|
|
/**
|
|
* This method sets the west pane to be the given JComponent.
|
|
*
|
|
* @param c The new west pane.
|
|
*/
|
|
public void setWestPane(JComponent c)
|
|
{
|
|
replacePane(westPane, c);
|
|
westPane = c;
|
|
}
|
|
|
|
/**
|
|
* This method returns the west pane.
|
|
*
|
|
* @return The west pane.
|
|
*/
|
|
public JComponent getWestPane()
|
|
{
|
|
return westPane;
|
|
}
|
|
|
|
/**
|
|
* This method returns the DesktopManager to use with the JInternalFrame.
|
|
*
|
|
* @return The DesktopManager to use with the JInternalFrame.
|
|
*/
|
|
protected DesktopManager getDesktopManager()
|
|
{
|
|
DesktopManager value = null;
|
|
JDesktopPane pane = frame.getDesktopPane();
|
|
if (pane != null)
|
|
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.
|
|
*/
|
|
protected DesktopManager createDesktopManager()
|
|
{
|
|
return new DefaultDesktopManager();
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that closes the JInternalFrame.
|
|
*
|
|
* @param f The JInternalFrame to close.
|
|
*/
|
|
protected void closeFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().closeFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that maximizes the JInternalFrame.
|
|
*
|
|
* @param f The JInternalFrame to maximize.
|
|
*/
|
|
protected void maximizeFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().maximizeFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that minimizes the JInternalFrame.
|
|
*
|
|
* @param f The JInternalFrame to minimize.
|
|
*/
|
|
protected void minimizeFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().minimizeFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that iconifies the JInternalFrame.
|
|
*
|
|
* @param f The JInternalFrame to iconify.
|
|
*/
|
|
protected void iconifyFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().iconifyFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that deiconifies the JInternalFrame.
|
|
*
|
|
* @param f The JInternalFrame to deiconify.
|
|
*/
|
|
protected void deiconifyFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().deiconifyFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that activates the JInternalFrame.
|
|
*
|
|
* @param f The JInternalFrame to activate.
|
|
*/
|
|
protected void activateFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().activateFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method that deactivates the JInternalFrame.
|
|
*
|
|
* @param f the JInternalFrame to deactivate
|
|
*/
|
|
protected void deactivateFrame(JInternalFrame f)
|
|
{
|
|
getDesktopManager().deactivateFrame(f);
|
|
}
|
|
|
|
/**
|
|
* This method returns a new ComponentListener for the JDesktopPane.
|
|
*
|
|
* @return A new ComponentListener.
|
|
*/
|
|
protected ComponentListener createComponentListener()
|
|
{
|
|
return new ComponentHandler();
|
|
}
|
|
|
|
/**
|
|
* This method returns a new GlassPaneDispatcher.
|
|
*
|
|
* @return A new GlassPaneDispatcher.
|
|
*/
|
|
protected MouseInputListener createGlassPaneDispatcher()
|
|
{
|
|
return new GlassPaneDispatcher();
|
|
}
|
|
}
|