| /* 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(); | |
| } | |
| } |