diff options
Diffstat (limited to 'libjava/classpath/java/awt/Frame.java')
| -rw-r--r-- | libjava/classpath/java/awt/Frame.java | 704 |
1 files changed, 704 insertions, 0 deletions
diff --git a/libjava/classpath/java/awt/Frame.java b/libjava/classpath/java/awt/Frame.java new file mode 100644 index 000000000..83bdb0947 --- /dev/null +++ b/libjava/classpath/java/awt/Frame.java @@ -0,0 +1,704 @@ +/* Frame.java -- AWT toplevel window + Copyright (C) 1999, 2000, 2002, 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 java.awt; + +import java.awt.peer.FramePeer; +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.Vector; + +import javax.accessibility.AccessibleContext; +import javax.accessibility.AccessibleRole; +import javax.accessibility.AccessibleState; +import javax.accessibility.AccessibleStateSet; + +/** + * This class is a top-level window with a title bar and window + * decorations. + * + * @author Aaron M. Renn (arenn@urbanophile.com) + */ +public class Frame extends Window implements MenuContainer +{ + + /** + * Constant for the default cursor. + * + * @deprecated Replaced by <code>Cursor.DEFAULT_CURSOR</code> instead. + */ + public static final int DEFAULT_CURSOR = Cursor.DEFAULT_CURSOR; + + /** + * Constant for a cross-hair cursor. + * + * @deprecated Use <code>Cursor.CROSSHAIR_CURSOR</code> instead. + */ + public static final int CROSSHAIR_CURSOR = Cursor.CROSSHAIR_CURSOR; + + /** + * Constant for a cursor over a text field. + * + * @deprecated Use <code>Cursor.TEXT_CURSOR</code> instead. + */ + public static final int TEXT_CURSOR = Cursor.TEXT_CURSOR; + + /** + * Constant for a cursor to display while waiting for an action to complete. + * + * @deprecated Use <code>Cursor.WAIT_CURSOR</code>. + */ + public static final int WAIT_CURSOR = Cursor.WAIT_CURSOR; + + /** + * Cursor used over SW corner of window decorations. + * + * @deprecated Use <code>Cursor.SW_RESIZE_CURSOR</code> instead. + */ + public static final int SW_RESIZE_CURSOR = Cursor.SW_RESIZE_CURSOR; + + /** + * Cursor used over SE corner of window decorations. + * @deprecated Use <code>Cursor.SE_RESIZE_CURSOR</code> instead. + */ + public static final int SE_RESIZE_CURSOR = Cursor.SE_RESIZE_CURSOR; + + /** + * Cursor used over NW corner of window decorations. + * + * @deprecated Use <code>Cursor.NW_RESIZE_CURSOR</code> instead. + */ + public static final int NW_RESIZE_CURSOR = Cursor.NW_RESIZE_CURSOR; + + /** + * Cursor used over NE corner of window decorations. + * + * @deprecated Use <code>Cursor.NE_RESIZE_CURSOR</code> instead. + */ + public static final int NE_RESIZE_CURSOR = Cursor.NE_RESIZE_CURSOR; + + /** + * Cursor used over N edge of window decorations. + * + * @deprecated Use <code>Cursor.N_RESIZE_CURSOR</code> instead. + */ + public static final int N_RESIZE_CURSOR = Cursor.N_RESIZE_CURSOR; + + /** + * Cursor used over S edge of window decorations. + * + * @deprecated Use <code>Cursor.S_RESIZE_CURSOR</code> instead. + */ + public static final int S_RESIZE_CURSOR = Cursor.S_RESIZE_CURSOR; + + /** + * Cursor used over E edge of window decorations. + * + * @deprecated Use <code>Cursor.E_RESIZE_CURSOR</code> instead. + */ + public static final int E_RESIZE_CURSOR = Cursor.E_RESIZE_CURSOR; + + /** + * Cursor used over W edge of window decorations. + * + * @deprecated Use <code>Cursor.W_RESIZE_CURSOR</code> instead. + */ + public static final int W_RESIZE_CURSOR = Cursor.W_RESIZE_CURSOR; + + /** + * Constant for a hand cursor. + * + * @deprecated Use <code>Cursor.HAND_CURSOR</code> instead. + */ + public static final int HAND_CURSOR = Cursor.HAND_CURSOR; + + /** + * Constant for a cursor used during window move operations. + * + * @deprecated Use <code>Cursor.MOVE_CURSOR</code> instead. + */ + public static final int MOVE_CURSOR = Cursor.MOVE_CURSOR; + + public static final int ICONIFIED = 1; + public static final int MAXIMIZED_BOTH = 6; + public static final int MAXIMIZED_HORIZ = 2; + public static final int MAXIMIZED_VERT = 4; + public static final int NORMAL = 0; + +//Serialization version constant + private static final long serialVersionUID = 2673458971256075116L; + + /** + * @serial The version of the class data being serialized + * FIXME: what is this value? + */ + private int frameSerializedDataVersion; + + /** + * @serial Image used as the icon when this frame is minimized. + */ + private Image icon; + + /** + * @serial Constant used by the JDK Motif peer set. Not used in + * this implementation. + */ + private boolean mbManagement; + + /** + * @serial The menu bar for this frame. + */ + private MenuBar menuBar; + + /** + * @serial A list of other top-level windows owned by this window. + */ + Vector ownedWindows = new Vector(); + + /** + * @serial Indicates whether or not this frame is resizable. + */ + private boolean resizable = true; + + /** + * @serial The state of this frame. + * // FIXME: What are the values here? + * This is package-private to avoid an accessor method. + */ + int state; + + /** + * @serial The title of the frame. + */ + private String title = ""; + + /** + * Maximized bounds for this frame. + */ + private Rectangle maximizedBounds; + + /** + * This field indicates whether the frame is undecorated or not. + */ + private boolean undecorated = false; + + /* + * The number used to generate the name returned by getName. + */ + private static transient long next_frame_number; + + /** + * Initializes a new instance of <code>Frame</code> that is not visible + * and has no title. + */ + public Frame() + { + this(""); + noteFrame(this); + } + + /** + * Initializes a new instance of <code>Frame</code> that is not visible + * and has the specified title. + * + * @param title the title of this frame + */ + public Frame(String title) + { + super(); + this.title = title; + // Top-level frames are initially invisible. + visible = false; + noteFrame(this); + } + + public Frame(GraphicsConfiguration gc) + { + super(gc); + visible = false; + noteFrame(this); + } + + public Frame(String title, GraphicsConfiguration gc) + { + super(gc); + setTitle(title); + visible = false; + noteFrame(this); + } + + /** + * Returns this frame's title string. + * + * @return this frame's title string + */ + public String getTitle() + { + return title; + } + + /** + * Sets this frame's title to the specified value. + * + * @param title the new frame title + */ + public synchronized void setTitle(String title) + { + this.title = title; + if (peer != null) + ((FramePeer) peer).setTitle(title); + } + + /** + * Returns this frame's icon. + * + * @return this frame's icon, or <code>null</code> if this frame does not + * have an icon + */ + public Image getIconImage() + { + return icon; + } + + /** + * Sets this frame's icon to the specified value. + * + * @icon the new icon for this frame + */ + public synchronized void setIconImage(Image icon) + { + this.icon = icon; + if (peer != null) + ((FramePeer) peer).setIconImage(icon); + } + + /** + * Returns this frame's menu bar. + * + * @return this frame's menu bar, or <code>null</code> if this frame + * does not have a menu bar + */ + public MenuBar getMenuBar() + { + return menuBar; + } + + /** + * Sets this frame's menu bar. Removes any existing menu bar. If the + * given menu bar is part of another frame it will be removed from + * that frame. + * + * @param menuBar the new menu bar for this frame + */ + public synchronized void setMenuBar(MenuBar menuBar) + { + if (this.menuBar != null) + remove(this.menuBar); + + this.menuBar = menuBar; + if (menuBar != null) + { + MenuContainer parent = menuBar.getParent(); + if (parent != null) + parent.remove(menuBar); + menuBar.setParent(this); + + // Create local copy for thread safety. + FramePeer p = (FramePeer) peer; + if (p != null) + { + if (menuBar != null) + menuBar.addNotify(); + if (valid) + invalidate(); + p.setMenuBar(menuBar); + } + } + } + + /** + * Tests whether or not this frame is resizable. This will be + * <code>true</code> by default. + * + * @return <code>true</code> if this frame is resizable, <code>false</code> + * otherwise + */ + public boolean isResizable() + { + return resizable; + } + + /** + * Sets the resizability of this frame to the specified value. + * + * @param resizable <code>true</code> to make the frame resizable, + * <code>false</code> to make it non-resizable + */ + public synchronized void setResizable(boolean resizable) + { + this.resizable = resizable; + if (peer != null) + ((FramePeer) peer).setResizable(resizable); + } + + /** + * Returns the cursor type of the cursor for this window. This will + * be one of the constants in this class. + * + * @return the cursor type for this frame + * + * @deprecated Use <code>Component.getCursor()</code> instead. + */ + public int getCursorType() + { + return getCursor().getType(); + } + + /** + * Sets the cursor for this window to the specified type. The specified + * type should be one of the constants in this class. + * + * @param type the cursor type + * + * @deprecated Use <code>Component.setCursor(Cursor)</code> instead. + */ + public void setCursor(int type) + { + setCursor(new Cursor(type)); + } + + /** + * Removes the specified menu component from this frame. If it is + * the current MenuBar it is removed from the frame. If it is a + * Popup it is removed from this component. If it is any other menu + * component it is ignored. + * + * @param menu the menu component to remove + */ + public void remove(MenuComponent menu) + { + if (menu == menuBar) + { + if (menuBar != null) + { + if (peer != null) + { + ((FramePeer) peer).setMenuBar(null); + menuBar.removeNotify(); + } + menuBar.setParent(null); + } + menuBar = null; + } + else + super.remove(menu); + } + + public void addNotify() + { + if (menuBar != null) + menuBar.addNotify(); + if (peer == null) + peer = getToolkit ().createFrame (this); + + super.addNotify(); + } + + public void removeNotify() + { + if (menuBar != null) + menuBar.removeNotify(); + super.removeNotify(); + } + + /** + * Returns a debugging string describing this window. + * + * @return a debugging string describing this window + */ + protected String paramString() + { + String title = getTitle(); + + String resizable = ""; + if (isResizable ()) + resizable = ",resizable"; + + String state = ""; + switch (getState ()) + { + case NORMAL: + state = ",normal"; + break; + case ICONIFIED: + state = ",iconified"; + break; + case MAXIMIZED_BOTH: + state = ",maximized-both"; + break; + case MAXIMIZED_HORIZ: + state = ",maximized-horiz"; + break; + case MAXIMIZED_VERT: + state = ",maximized-vert"; + break; + } + + return super.paramString () + ",title=" + title + resizable + state; + } + + /** + * The list of active frames. GC'ed frames get removed in noteFrame(). + */ + private static ArrayList<WeakReference<Frame>> weakFrames = + new ArrayList<WeakReference<Frame>>(); + + /** + * The death queue for all frames. + */ + private static ReferenceQueue weakFramesQueue = + new ReferenceQueue<Frame>(); + + private static void noteFrame(Frame f) + { + synchronized (weakFrames) + { + // Remove GCed frames from the list. + Reference ref = weakFramesQueue.poll(); + while (ref != null) + { + weakFrames.remove(ref); + ref = weakFramesQueue.poll(); + } + // Add new frame. + weakFrames.add(new WeakReference<Frame>(f)); + } + } + + /** + * Returns <code>true</code> when there are any displayable frames, + * <code>false</code> otherwise. + * + * @return <code>true</code> when there are any displayable frames, + * <code>false</code> otherwise + */ + static boolean hasDisplayableFrames() + { + synchronized (weakFrames) + { + for (WeakReference<Frame> r : Frame.weakFrames) + { + Frame f = (Frame) r.get(); + if (f != null && f.isDisplayable()) + return true; + } + } + return false; + } + + public static Frame[] getFrames() + { + synchronized (weakFrames) + { + ArrayList<Frame> existingFrames = new ArrayList<Frame>(); + for (WeakReference<Frame> ref : weakFrames) + { + Frame f = ref.get(); + if (f != null) + { + existingFrames.add(f); + } + } + Frame[] frames = new Frame[existingFrames.size()]; + frames = existingFrames.toArray(frames); + return frames; + } + } + + public void setState(int state) + { + int current_state = getExtendedState (); + + if (state == NORMAL + && (current_state & ICONIFIED) != 0) + setExtendedState(current_state | ICONIFIED); + + if (state == ICONIFIED + && (current_state & ~ICONIFIED) == 0) + setExtendedState(current_state & ~ICONIFIED); + } + + public int getState() + { + return (getExtendedState() & ICONIFIED) != 0 ? ICONIFIED : NORMAL; + } + + /** + * @since 1.4 + */ + public void setExtendedState(int state) + { + if (getToolkit().isFrameStateSupported(state)) + { + this.state = state; + FramePeer p = (FramePeer) peer; + if (p != null) + p.setState(state); + } + } + + /** + * @since 1.4 + */ + public int getExtendedState() + { + FramePeer p = (FramePeer) peer; + if (p != null) + state = p.getState(); + return state; + } + + /** + * @since 1.4 + */ + public void setMaximizedBounds(Rectangle maximizedBounds) + { + this.maximizedBounds = maximizedBounds; + } + + /** + * Returns the maximized bounds of this frame. + * + * @return the maximized rectangle, may be null + * + * @since 1.4 + */ + public Rectangle getMaximizedBounds() + { + return maximizedBounds; + } + + /** + * Returns whether this frame is undecorated or not. + * + * @since 1.4 + */ + public boolean isUndecorated() + { + return undecorated; + } + + /** + * Disables or enables decorations for this frame. This method can only be + * called while the frame is not displayable. + * + * @throws IllegalComponentStateException if this frame is displayable + * + * @since 1.4 + */ + public void setUndecorated(boolean undecorated) + { + if (isDisplayable()) + throw new IllegalComponentStateException(); + + this.undecorated = undecorated; + } + + /** + * Generate a unique name for this frame. + * + * @return a unique name for this frame + */ + String generateName() + { + return "frame" + getUniqueLong(); + } + + private static synchronized long getUniqueLong() + { + return next_frame_number++; + } + + /** + * Accessibility support for <code>Frame</code>. + */ + protected class AccessibleAWTFrame extends AccessibleAWTWindow + { + private static final long serialVersionUID = -6172960752956030250L; + + /** + * Gets the role of this object. + * @return AccessibleRole.FRAME + */ + public AccessibleRole getAccessibleRole() + { + return AccessibleRole.FRAME; + } + + /** + * Gets the state set of this object. + * @return The current state of this frame. + */ + public AccessibleStateSet getAccessibleStateSet() + { + AccessibleStateSet states = super.getAccessibleStateSet(); + if (isResizable()) + states.add(AccessibleState.RESIZABLE); + if ((state & ICONIFIED) != 0) + states.add(AccessibleState.ICONIFIED); + return states; + } + } + + /** + * Gets the AccessibleContext associated with this <code>Frame</code>. + * The context is created, if necessary. + * + * @return the associated context + */ + public AccessibleContext getAccessibleContext() + { + // Create the context if this is the first request. + if (accessibleContext == null) + accessibleContext = new AccessibleAWTFrame(); + return accessibleContext; + } +} |