| Frames | No Frames |
1: /* JInternalFrame.java -- 2: Copyright (C) 2002, 2004, 2005, 2006, Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.swing; 40: 41: import java.awt.BorderLayout; 42: import java.awt.Component; 43: import java.awt.Container; 44: import java.awt.Graphics; 45: import java.awt.IllegalComponentStateException; 46: import java.awt.KeyboardFocusManager; 47: import java.awt.LayoutManager; 48: import java.awt.Rectangle; 49: import java.beans.PropertyChangeEvent; 50: import java.beans.PropertyVetoException; 51: 52: import javax.accessibility.Accessible; 53: import javax.accessibility.AccessibleContext; 54: import javax.accessibility.AccessibleRole; 55: import javax.accessibility.AccessibleValue; 56: import javax.swing.event.InternalFrameEvent; 57: import javax.swing.event.InternalFrameListener; 58: import javax.swing.plaf.DesktopIconUI; 59: import javax.swing.plaf.InternalFrameUI; 60: 61: /** 62: * This class implements a Swing widget that looks and acts like a native 63: * frame. The frame can be dragged, resized, closed, etc. Typically, 64: * JInternalFrames are placed in JDesktopPanes. The actions that the 65: * JInternalFrame performs (maximizing, minimizing, etc.) are performed by a 66: * DesktopManager. As with regular frames, components are added by calling 67: * frame.getContentPane().add. 68: */ 69: public class JInternalFrame extends JComponent implements Accessible, 70: WindowConstants, 71: RootPaneContainer 72: { 73: 74: private static final long serialVersionUID = -5425177187760785402L; 75: 76: /** 77: * Provides the accessibility features for the <code>JInternalFrame</code> 78: * component. 79: */ 80: protected class AccessibleJInternalFrame extends AccessibleJComponent 81: implements AccessibleValue 82: { 83: private static final long serialVersionUID = 5931936924175476797L; 84: 85: /** 86: * Creates a new <code>AccessibleJInternalFrame</code> instance. 87: */ 88: protected AccessibleJInternalFrame() 89: { 90: super(); 91: } 92: 93: /** 94: * Returns the frame title. 95: * 96: * @return The frame title. 97: */ 98: public String getAccessibleName() 99: { 100: return getTitle(); 101: } 102: 103: /** 104: * Returns the accessible role for the <code>JInternalFrame</code> 105: * component. 106: * 107: * @return {@link AccessibleRole#INTERNAL_FRAME}. 108: */ 109: public AccessibleRole getAccessibleRole() 110: { 111: return AccessibleRole.INTERNAL_FRAME; 112: } 113: 114: /** 115: * Returns an object that provides access to the current, minimum and 116: * maximum values for the {@link JInternalFrame}. Since this class 117: * implements {@link AccessibleValue}, it returns itself. 118: * 119: * @return The accessible value. 120: */ 121: public AccessibleValue getAccessibleValue() 122: { 123: return this; 124: } 125: 126: /** 127: * Returns the current layer for the {@link JInternalFrame} component, 128: * as an {@link Integer}. 129: * 130: * @return The layer for the {@link JInternalFrame} component. 131: */ 132: public Number getCurrentAccessibleValue() 133: { 134: return new Integer(getLayer()); 135: } 136: 137: /** 138: * Returns the maximum permitted accessible value. 139: * 140: * @return <code>Integer(Integer.MAX_VALUE)</code>. 141: */ 142: public Number getMaximumAccessibleValue() 143: { 144: return new Integer(Integer.MAX_VALUE); 145: } 146: 147: /** 148: * Returns the minimum permitted accessible value. 149: * 150: * @return <code>Integer(Integer.MIN_VALUE)</code>. 151: */ 152: public Number getMinimumAccessibleValue() 153: { 154: return new Integer(Integer.MIN_VALUE); 155: } 156: 157: /** 158: * Sets the layer for the internal frame. 159: * 160: * @param n the layer (see the constants defined in {@link JLayeredPane}). 161: * 162: * @return <code>true</code> if the value is set, and <code>false</code> 163: * if it was not set. 164: */ 165: public boolean setCurrentAccessibleValue(Number n) 166: { 167: if (n == null) 168: return false; 169: setLayer(n.intValue()); 170: return true; 171: } 172: } 173: 174: /** 175: * This class represents the JInternalFrame while it is iconified. 176: */ 177: public static class JDesktopIcon extends JComponent implements Accessible 178: { 179: /** 180: * Provides the accessibility features for the <code>JDesktopIcon</code> 181: * component. 182: */ 183: protected class AccessibleJDesktopIcon extends AccessibleJComponent 184: implements AccessibleValue 185: { 186: private static final long serialVersionUID = 5035560458941637802L; 187: 188: /** 189: * Creates a new <code>AccessibleJDesktopIcon</code> instance. 190: */ 191: protected AccessibleJDesktopIcon() 192: { 193: super(); 194: } 195: 196: /** 197: * Returns the accessible role for the <code>JDesktopIcon</code> 198: * component. 199: * 200: * @return {@link AccessibleRole#DESKTOP_ICON}. 201: */ 202: public AccessibleRole getAccessibleRole() 203: { 204: return AccessibleRole.DESKTOP_ICON; 205: } 206: 207: /** 208: * Returns an object that provides access to the current, minimum and 209: * maximum values for the {@link JDesktopIcon}. Since this class 210: * implements {@link AccessibleValue}, it returns itself. 211: * 212: * @return The accessible value. 213: */ 214: public AccessibleValue getAccessibleValue() 215: { 216: return this; 217: } 218: 219: /** 220: * Returns the current layer for the {@link JInternalFrame} component 221: * represented by this <code>JDesktopIcon</code>, as an {@link Integer}. 222: * 223: * @return The layer. 224: */ 225: public Number getCurrentAccessibleValue() 226: { 227: return new Integer(frame.getLayer()); 228: } 229: 230: /** 231: * Returns the maximum permitted accessible value. 232: * 233: * @return <code>Integer(Integer.MAX_VALUE)</code>. 234: */ 235: public Number getMaximumAccessibleValue() 236: { 237: return new Integer(Integer.MAX_VALUE); 238: } 239: 240: /** 241: * Returns the minimum permitted accessible value. 242: * 243: * @return <code>Integer(Integer.MIN_VALUE)</code>. 244: */ 245: public Number getMinimumAccessibleValue() 246: { 247: return new Integer(Integer.MIN_VALUE); 248: } 249: 250: /** 251: * Sets the layer for the internal frame represented by this 252: * <code>JDesktopIcon</code> component. 253: * 254: * @param n the layer (see the constants defined in 255: * {@link JLayeredPane}). 256: * 257: * @return <code>true</code> if the value is set, and <code>false</code> 258: * if it was not set. 259: */ 260: public boolean setCurrentAccessibleValue(Number n) 261: { 262: if (n == null) 263: return false; 264: frame.setLayer(n.intValue()); 265: return true; 266: } 267: } 268: 269: private static final long serialVersionUID = 4672973344731387687L; 270: 271: /** The JInternalFrame this DesktopIcon represents. */ 272: JInternalFrame frame; 273: 274: /** 275: * Creates a new JDesktopIcon object for representing the given frame. 276: * 277: * @param f The JInternalFrame to represent. 278: */ 279: public JDesktopIcon(JInternalFrame f) 280: { 281: frame = f; 282: updateUI(); 283: } 284: 285: /** 286: * Returns the object that provides accessibility features for this 287: * <code>JDesktopIcon</code> component. 288: * 289: * @return The accessible context (an instance of 290: * {@link AccessibleJDesktopIcon}). 291: */ 292: public AccessibleContext getAccessibleContext() 293: { 294: if (accessibleContext == null) 295: accessibleContext = new AccessibleJDesktopIcon(); 296: return accessibleContext; 297: } 298: 299: /** 300: * This method returns the JDesktopPane this JDesktopIcon is in. 301: * 302: * @return The JDesktopPane this JDesktopIcon is in. 303: */ 304: public JDesktopPane getDesktopPane() 305: { 306: JDesktopPane p = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class, 307: this); 308: return p; 309: } 310: 311: /** 312: * This method returns the JInternalFrame this JDesktopIcon represents. 313: * 314: * @return The JInternalFrame this JDesktopIcon represents. 315: */ 316: public JInternalFrame getInternalFrame() 317: { 318: return frame; 319: } 320: 321: /** 322: * This method returns the UI that is responsible for the JDesktopIcon. 323: * 324: * @return The UI that is responsible for the JDesktopIcon. 325: */ 326: public DesktopIconUI getUI() 327: { 328: return (DesktopIconUI) ui; 329: } 330: 331: /** 332: * This method returns the String identifier that is used to determine 333: * which class is used for JDesktopIcon's UI. 334: * 335: * @return A String identifier for the UI class. 336: */ 337: public String getUIClassID() 338: { 339: return "DesktopIconUI"; 340: } 341: 342: /** 343: * This method sets the JInternalFrame that this JDesktopIcon represents. 344: * 345: * @param f The JInternalFrame that this JDesktopIcon represents. 346: */ 347: public void setInternalFrame(JInternalFrame f) 348: { 349: frame = f; 350: } 351: 352: /** 353: * This method sets the UI used for this JDesktopIcon. 354: * 355: * @param ui The UI to use. 356: */ 357: public void setUI(DesktopIconUI ui) 358: { 359: super.setUI(ui); 360: } 361: 362: /** 363: * This method restores the UI property to the defaults. 364: */ 365: public void updateUI() 366: { 367: setUI((DesktopIconUI) UIManager.getUI(this)); 368: } 369: } 370: 371: /** 372: * The property fired in a PropertyChangeEvent when the contentPane property 373: * changes. 374: */ 375: public static final String CONTENT_PANE_PROPERTY = "contentPane"; 376: 377: /** 378: * The property fired in a PropertyChangeEvent when the frameIcon property 379: * changes. 380: */ 381: public static final String FRAME_ICON_PROPERTY = "frameIcon"; 382: 383: /** 384: * The property fired in a PropertyChangeEvent when the glassPane property 385: * changes. 386: */ 387: public static final String GLASS_PANE_PROPERTY = "glassPane"; 388: 389: /** 390: * The property fired in a PropertyChangeEvent when the closed property 391: * changes. 392: */ 393: public static final String IS_CLOSED_PROPERTY = "closed"; 394: 395: /** 396: * The property fired in a PropertyChangeEvent when the icon property 397: * changes. 398: */ 399: public static final String IS_ICON_PROPERTY = "icon"; 400: 401: /** 402: * The property fired in a PropertyChangeEvent when the maximum property 403: * changes. 404: */ 405: public static final String IS_MAXIMUM_PROPERTY = "maximum"; 406: 407: /** 408: * The property fired in a PropertyChangeEvent when the selected property 409: * changes. 410: */ 411: public static final String IS_SELECTED_PROPERTY = "selected"; 412: 413: /** 414: * The property fired in a PropertyChangeEvent when the layeredPane property 415: * changes. 416: */ 417: public static final String LAYERED_PANE_PROPERTY = "layeredPane"; 418: 419: /** 420: * The property fired in a PropertyChangeEvent when the jMenuBar property 421: * changes. 422: */ 423: public static final String MENU_BAR_PROPERTY = "JMenuBar"; 424: 425: /** 426: * The property fired in a PropertyChangeEvent when the rootPane property 427: * changes. 428: */ 429: public static final String ROOT_PANE_PROPERTY = "rootPane"; 430: 431: /** 432: * The property fired in a PropertyChangeEvent when the title property 433: * changes. 434: */ 435: public static final String TITLE_PROPERTY = "title"; 436: 437: /** Whether the JInternalFrame is closable. */ 438: protected boolean closable; 439: 440: /** Whether the JInternalFrame can be iconified. */ 441: protected boolean iconable; 442: 443: /** Whether the JInternalFrame is closed. */ 444: protected boolean isClosed; 445: 446: /** Whether the JInternalFrame has been iconified. */ 447: protected boolean isIcon; 448: 449: /** Whether the JInternalFrame has been maximized. */ 450: protected boolean isMaximum; 451: 452: /** Whether the JInternalFrame is the active frame. */ 453: protected boolean isSelected; 454: 455: /** Whether the JInternalFrame can be maximized. */ 456: protected boolean maximizable; 457: 458: /** 459: * Whether the JInternalFrame has rootPaneChecking enabled. 460: * 461: * @specnote Should be false to comply with J2SE 5.0 462: */ 463: protected boolean rootPaneCheckingEnabled = false; 464: 465: /** Whether the JInternalFrame is resizable. */ 466: protected boolean resizable; 467: 468: /** 469: * The JDesktopIcon that represents the JInternalFrame while it is 470: * iconified. 471: */ 472: protected JDesktopIcon desktopIcon; 473: 474: /** The icon used in the JMenuBar in the TitlePane. */ 475: protected Icon frameIcon; 476: 477: /** The rootPane of the JInternalFrame. */ 478: protected JRootPane rootPane; 479: 480: /** The title on the TitlePane of the JInternalFrame. */ 481: protected String title; 482: 483: /** The bounds of the JInternalFrame before it was maximized. */ 484: private transient Rectangle storedBounds; 485: 486: /** The Component that receives focus by default. */ 487: private transient Component defaultFocus; 488: 489: /** The default close action taken, */ 490: private transient int defaultCloseOperation = DISPOSE_ON_CLOSE; 491: 492: /** Whether the JInternalFrame has become visible for the very first time. */ 493: private transient boolean isFirstTimeVisible = true; 494: 495: /** DOCUMENT ME! */ 496: private transient boolean wasIcon = false; 497: 498: /** 499: * Creates a new JInternalFrame object that has an empty string for its 500: * title, and is non-resizable, non-maximizable, non-iconifiable, and 501: * non-closable. 502: */ 503: public JInternalFrame() 504: { 505: this("", false, false, false, false); 506: } 507: 508: /** 509: * Creates a new JInternalFrame object with the given title and is 510: * non-resizable, non-maximizable, non-iconifiable, and non-closable. 511: * 512: * @param title The title displayed in the JInternalFrame. 513: */ 514: public JInternalFrame(String title) 515: { 516: this(title, false, false, false, false); 517: } 518: 519: /** 520: * Creates a new JInternalFrame object with the given title and resizable 521: * properties. The JInternalFrame is non-maximizable, non-iconifiable, and 522: * non-closable. 523: * 524: * @param title The title displayed in the JInternalFrame. 525: * @param resizable Whether the JInternalFrame is resizable. 526: */ 527: public JInternalFrame(String title, boolean resizable) 528: { 529: this(title, resizable, false, false, false); 530: } 531: 532: /** 533: * Creates a new JInternalFrame object with the given title, resizable, and 534: * closable properties. The JInternalFrame is non-maximizable and 535: * non-iconifiable. 536: * 537: * @param title The title displayed in the JInternalFrame. 538: * @param resizable Whether the JInternalFrame is resizable. 539: * @param closable Whether the JInternalFrame is closable. 540: */ 541: public JInternalFrame(String title, boolean resizable, boolean closable) 542: { 543: this(title, resizable, closable, false, false); 544: } 545: 546: /** 547: * Creates a new JInternalFrame object with the given title, resizable, 548: * closable and maximizable properties. The JInternalFrame is 549: * non-iconifiable. 550: * 551: * @param title The title displayed in the JInternalFrame. 552: * @param resizable Whether the JInternalFrame is resizable. 553: * @param closable Whether the JInternalFrame is closable. 554: * @param maximizable Whether the JInternalFrame is maximizable. 555: */ 556: public JInternalFrame(String title, boolean resizable, boolean closable, 557: boolean maximizable) 558: { 559: this(title, resizable, closable, maximizable, false); 560: } 561: 562: /** 563: * Creates a new JInternalFrame object with the given title, resizable, 564: * closable, maximizable and iconifiable properties. 565: * 566: * @param title The title displayed in the JInternalFrame. 567: * @param resizable Whether the JInternalFrame is resizable. 568: * @param closable Whether the JInternalFrame is closable. 569: * @param maximizable Whether the JInternalFrame is maximizable. 570: * @param iconifiable Whether the JInternalFrame is iconifiable. 571: */ 572: public JInternalFrame(String title, boolean resizable, boolean closable, 573: boolean maximizable, boolean iconifiable) 574: { 575: this.title = title; 576: this.resizable = resizable; 577: this.closable = closable; 578: this.maximizable = maximizable; 579: this.iconable = iconifiable; 580: isMaximum = false; 581: setRootPane(createRootPane()); 582: // JInternalFrames are invisible and opaque by default. 583: setVisible(false); 584: setOpaque(true); 585: desktopIcon = new JDesktopIcon(this); 586: updateUI(); 587: setRootPaneCheckingEnabled(true); // Done the init stage, now adds go to content pane. 588: } 589: 590: /** 591: * This method adds Components to this Container. For JInternalFrames, 592: * instead of calling add directly on the JInternalFrame, it should be 593: * called with JInternalFrame.getContentPane().add. If root pane checking 594: * is enabled, calling this method will cause an exception to be thrown. 595: * 596: * @param comp The Component to add. 597: * @param constraints The constraints on the Component added. 598: * @param index The position to place the Component. 599: * 600: * @throws Error DOCUMENT ME! 601: */ 602: protected void addImpl(Component comp, Object constraints, int index) 603: { 604: // If we're in the initialization stage use super.add. Here we add the 605: // rootPane as well as the title bar and other stuff. 606: // Otherwise pass the add onto the content pane. 607: if (isRootPaneCheckingEnabled()) 608: getContentPane().add(comp, constraints, index); 609: else 610: super.addImpl(comp,constraints, index); 611: } 612: 613: /** 614: * This method adds an InternalFrameListener to this JInternalFrame. 615: * 616: * @param l The listener to add. 617: */ 618: public void addInternalFrameListener(InternalFrameListener l) 619: { 620: listenerList.add(InternalFrameListener.class, l); 621: } 622: 623: /** 624: * This method is used to create a root pane for the JInternalFrame. This 625: * method is called by the constructors. 626: * 627: * @return A root pane for the JInternalFrame to use. 628: */ 629: protected JRootPane createRootPane() 630: { 631: return new JRootPane(); 632: } 633: 634: /** 635: * This method makes this JInternalFrame invisible, unselected and closed. 636: * If this JInternalFrame is not closed already, it will fire an 637: * INTERNAL_FRAME_CLoSED event. This method is similar to setClosed but it 638: * doesn't give vetoable listeners a chance to veto and it will not fire an 639: * INTERNAL_FRAME_CLOSING event. 640: */ 641: public void dispose() 642: { 643: if (isVisible()) 644: setVisible(false); 645: if (isSelected()) 646: { 647: try 648: { 649: setSelected(false); 650: } 651: catch (PropertyVetoException e) 652: { 653: // Do nothing if they don't want to be unselected. 654: } 655: } 656: if (! isClosed) 657: { 658: firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE); 659: isClosed = true; 660: } 661: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED); 662: } 663: 664: /** 665: * This method is used for closing this JInternalFrame. It fires an 666: * INTERNAL_FRAME_CLOSING event and then performs the action specified by 667: * the default close operation. 668: */ 669: public void doDefaultCloseAction() 670: { 671: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING); 672: switch (getDefaultCloseOperation()) 673: { 674: case HIDE_ON_CLOSE: 675: setVisible(false); 676: break; 677: case DISPOSE_ON_CLOSE: 678: dispose(); 679: break; 680: } 681: } 682: 683: /** 684: * This method fires an InternalFrameEvent to the listeners. 685: * 686: * @param id The type of event being fired. See InternalFrameEvent. 687: */ 688: protected void fireInternalFrameEvent(int id) 689: { 690: Object[] ifListeners = listenerList.getListenerList(); 691: InternalFrameEvent evt = new InternalFrameEvent(this, id); 692: switch (id) 693: { 694: case InternalFrameEvent.INTERNAL_FRAME_CLOSING: 695: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 696: { 697: if (ifListeners[i] == InternalFrameListener.class) 698: ((InternalFrameListener) ifListeners[i + 1]) 699: .internalFrameClosing(evt); 700: } 701: break; 702: case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED: 703: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 704: { 705: if (ifListeners[i] == InternalFrameListener.class) 706: ((InternalFrameListener) ifListeners[i + 1]) 707: .internalFrameActivated(evt); 708: } 709: break; 710: case InternalFrameEvent.INTERNAL_FRAME_CLOSED: 711: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 712: { 713: if (ifListeners[i] == InternalFrameListener.class) 714: ((InternalFrameListener) ifListeners[i + 1]).internalFrameClosed(evt); 715: } 716: break; 717: case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED: 718: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 719: { 720: if (ifListeners[i] == InternalFrameListener.class) 721: ((InternalFrameListener) ifListeners[i + 1]) 722: .internalFrameDeactivated(evt); 723: } 724: break; 725: case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED: 726: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 727: { 728: if (ifListeners[i] == InternalFrameListener.class) 729: ((InternalFrameListener) ifListeners[i + 1]) 730: .internalFrameDeiconified(evt); 731: } 732: break; 733: case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED: 734: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 735: { 736: if (ifListeners[i] == InternalFrameListener.class) 737: ((InternalFrameListener) ifListeners[i + 1]) 738: .internalFrameIconified(evt); 739: } 740: break; 741: case InternalFrameEvent.INTERNAL_FRAME_OPENED: 742: for (int i = ifListeners.length - 2; i >= 0; i -= 2) 743: { 744: if (ifListeners[i] == InternalFrameListener.class) 745: ((InternalFrameListener) ifListeners[i + 1]).internalFrameOpened(evt); 746: } 747: break; 748: } 749: } 750: 751: /** 752: * Returns the object that provides accessibility features for this 753: * <code>JInternalFrame</code> component. 754: * 755: * @return The accessible context (an instance of 756: * {@link AccessibleJInternalFrame}). 757: */ 758: public AccessibleContext getAccessibleContext() 759: { 760: if (accessibleContext == null) 761: accessibleContext = new AccessibleJInternalFrame(); 762: return accessibleContext; 763: } 764: 765: /** 766: * This method returns the Content Pane for this JInternalFrame. 767: * 768: * @return The Content Pane for this JInternalFrame. 769: */ 770: public Container getContentPane() 771: { 772: return getRootPane().getContentPane(); 773: } 774: 775: /** 776: * Returns a code for the default action taken when this 777: * <code>JInternalFrame</code> is closed. 778: * 779: * @return The action code (usually one of 780: * {@link WindowConstants#DO_NOTHING_ON_CLOSE}, 781: * {@link WindowConstants#HIDE_ON_CLOSE}, or 782: * {@link WindowConstants#DISPOSE_ON_CLOSE}). 783: * 784: * @see #setDefaultCloseOperation(int) 785: * @see #doDefaultCloseAction() 786: */ 787: public int getDefaultCloseOperation() 788: { 789: return defaultCloseOperation; 790: } 791: 792: /** 793: * Returns the <code>JDesktopIcon</code> that represents this 794: * <code>JInternalFrame</code> while it is iconified. 795: * 796: * @return The desktop icon component. 797: */ 798: public JDesktopIcon getDesktopIcon() 799: { 800: return desktopIcon; 801: } 802: 803: /** 804: * This method searches this JInternalFrame ancestors for an instance of 805: * JDesktopPane. If one is found, it is returned. If none is found, then it 806: * will search the JDesktopIcon for a JDesktopPane. 807: * 808: * @return The JDesktopPane that this JInternalFrame belongs to. 809: */ 810: public JDesktopPane getDesktopPane() 811: { 812: JDesktopPane value = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class, 813: this); 814: if (value == null && desktopIcon != null) 815: value = desktopIcon.getDesktopPane(); 816: return value; 817: } 818: 819: /** 820: * This method returns null because this must always be the root of a focus 821: * traversal. 822: * 823: * @return always null 824: * 825: * @since 1.4 826: */ 827: public final Container getFocusCycleRootAncestor() 828: { 829: // as defined. 830: return null; 831: } 832: 833: /** 834: * This method returns the child Component that will receive focus if this 835: * JInternalFrame is selected. 836: * 837: * @return The child Component that will receive focus. 838: */ 839: public Component getFocusOwner() 840: { 841: if (isSelected()) 842: { 843: Component focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); 844: if (SwingUtilities.isDescendingFrom(focus, this)) 845: { 846: defaultFocus = focus; 847: return focus; 848: } 849: } 850: return null; 851: } 852: 853: /** 854: * This method returns the Frame Icon (the icon used in the JInternalFrame 855: * TitlePane and iconified frame). 856: * 857: * @return The Frame Icon. 858: */ 859: public Icon getFrameIcon() 860: { 861: return frameIcon; 862: } 863: 864: /** 865: * This method returns the Glass Pane used with this JInternalFrame. 866: * 867: * @return The Glass Pane used with this JInternalFrame. 868: */ 869: public Component getGlassPane() 870: { 871: return getRootPane().getGlassPane(); 872: } 873: 874: /** 875: * This method returns an array of InternalFrameListeners that are listening 876: * to this JInternalFrame. 877: * 878: * @return An array of InternalFrameListeners that are listening to this 879: * JInternalFrame. 880: */ 881: public InternalFrameListener[] getInternalFrameListeners() 882: { 883: return (InternalFrameListener[]) listenerList.getListeners(InternalFrameListener.class); 884: } 885: 886: /** 887: * This method returns the JMenuBar for this JInternalFrame. 888: * 889: * @return The JMenuBar for this JInternalFrame. 890: */ 891: public JMenuBar getJMenuBar() 892: { 893: return getRootPane().getJMenuBar(); 894: } 895: 896: /** 897: * This method returns the layer that this JInternalFrame resides in. 898: * 899: * @return The layer that this JInternalFrame resides in. 900: */ 901: public int getLayer() 902: { 903: return JLayeredPane.getLayer(this); 904: } 905: 906: /** 907: * This method returns the LayeredPane for this JInternalFrame. 908: * 909: * @return The LayeredPane for this JInternalFrame. 910: */ 911: public JLayeredPane getLayeredPane() 912: { 913: return getRootPane().getLayeredPane(); 914: } 915: 916: /** 917: * This method is deprecated. This method returns the JMenuBar for this 918: * JInternalFrame. 919: * 920: * @return The JMenuBar for this JInternalFrame. 921: * 922: * @deprecated 1.0.3 923: */ 924: public JMenuBar getMenuBar() 925: { 926: return getJMenuBar(); 927: } 928: 929: /** 930: * This method returns the child Component that will receive focus when the 931: * JInternalFrame is selected. If the JInternalFrame is selected, this 932: * method returns getFocusOwner(). Otherwise, it will return the child 933: * Component that most recently requested focus. If that is null, then the 934: * initial focus Component is returned. If that is null, then the default 935: * focus component is returned. 936: * 937: * @return The most recent focus owner. 938: */ 939: public Component getMostRecentFocusOwner() 940: { 941: if (isSelected()) 942: return getFocusOwner(); 943: else 944: return defaultFocus; 945: } 946: 947: /** 948: * This method returns the bounds of the JInternalFrame if it is not 949: * maximized. If it is maximized, it returns the bounds of the 950: * JInternalFrame before it was maximized (the bounds that it will be 951: * restored to). 952: * 953: * @return A Rectangle that contains this JInternalFrame's normal bounds (or 954: * just its bounds if it is not maximized). 955: */ 956: public Rectangle getNormalBounds() 957: { 958: if (storedBounds == null) 959: return getBounds(); 960: else 961: return storedBounds; 962: } 963: 964: /** 965: * This method returns the Root Pane for this JInternalFrame. 966: * 967: * @return The Root Pane for this JInternalFrame. 968: */ 969: public JRootPane getRootPane() 970: { 971: return rootPane; 972: } 973: 974: /** 975: * Returns the frame's title. 976: * 977: * @return The frame's title (can be <code>null</code>). 978: * 979: * @see #setTitle(String) 980: */ 981: public String getTitle() 982: { 983: return title; 984: } 985: 986: /** 987: * This method returns the UI used to represent the JInternalFrame. 988: * 989: * @return The UI used to represent the JInternalFrame. 990: */ 991: public InternalFrameUI getUI() 992: { 993: return (InternalFrameUI) ui; 994: } 995: 996: /** 997: * This method returns a String identifier that is used to determine which 998: * class acts as the JInternalFrame's UI. 999: * 1000: * @return A String identifier to determine a UI class. 1001: */ 1002: public String getUIClassID() 1003: { 1004: return "InternalFrameUI"; 1005: } 1006: 1007: /** 1008: * This method returns null. 1009: * 1010: * @return null. 1011: */ 1012: public final String getWarningString() 1013: { 1014: // as defined. 1015: return null; 1016: } 1017: 1018: /** 1019: * This method deselects this JInternalFrame and hides it. 1020: */ 1021: public void hide() 1022: { 1023: if (isIcon()) 1024: getDesktopIcon().hide(); 1025: super.hide(); 1026: } 1027: 1028: /** 1029: * This method returns whether this JInternalFrame is closable. 1030: * 1031: * @return Whether this JInternalFrame is closable. 1032: */ 1033: public boolean isClosable() 1034: { 1035: return closable; 1036: } 1037: 1038: /** 1039: * This method returns whether this JInternalFrame has been closed. 1040: * 1041: * @return Whether this JInternalFrame is closed. 1042: */ 1043: public boolean isClosed() 1044: { 1045: return isClosed; 1046: } 1047: 1048: /** 1049: * This must always return true. 1050: * 1051: * @return always true 1052: * 1053: * @since 1.4 1054: */ 1055: public final boolean isFocusCycleRoot() 1056: { 1057: return true; 1058: } 1059: 1060: /** 1061: * This method returns whether this JInternalFrame is currently iconified. 1062: * 1063: * @return Whether this JInternalFrame is currently iconified. 1064: */ 1065: public boolean isIcon() 1066: { 1067: return isIcon; 1068: } 1069: 1070: /** 1071: * This method returns whether the JInternalFrame can be iconified. 1072: * 1073: * @return Whether the JInternalFrame can be iconified. 1074: */ 1075: public boolean isIconifiable() 1076: { 1077: return iconable; 1078: } 1079: 1080: /** 1081: * This method returns whether this JInternalFrame can be maximized. 1082: * 1083: * @return Whether this JInternalFrame can be maximized. 1084: */ 1085: public boolean isMaximizable() 1086: { 1087: return maximizable; 1088: } 1089: 1090: /** 1091: * This method returns whether this JInternalFrame is currently maximized. 1092: * 1093: * @return Whether this JInternalFrame is maximized. 1094: */ 1095: public boolean isMaximum() 1096: { 1097: return isMaximum; 1098: } 1099: 1100: /** 1101: * This method returns whether this JInternalFrame is resizable. 1102: * 1103: * @return Whether this JInternalFrame is resizable. 1104: */ 1105: public boolean isResizable() 1106: { 1107: return resizable; 1108: } 1109: 1110: /** 1111: * This method returns whether root pane checking is enabled. If root pane 1112: * checking is enabled, then calls to addImpl and setLayout will throw 1113: * exceptions. 1114: * 1115: * @return Whether root pane checking is enabled. 1116: */ 1117: protected boolean isRootPaneCheckingEnabled() 1118: { 1119: return rootPaneCheckingEnabled; 1120: } 1121: 1122: /** 1123: * This method returns whether this JInternalFrame is selected. 1124: * 1125: * @return Whether this JInternalFrame is selected. 1126: */ 1127: public boolean isSelected() 1128: { 1129: return isSelected; 1130: } 1131: 1132: /** 1133: * A helper method that moves this JInternalFrame to the back if the parent 1134: * is a JLayeredPane. 1135: */ 1136: public void moveToBack() 1137: { 1138: Container p = getParent(); 1139: if (p instanceof JLayeredPane) 1140: ((JLayeredPane) p).moveToBack(this); 1141: } 1142: 1143: /** 1144: * A helper method that moves this JInternalFrame to the front if the parent 1145: * is a JLayeredPane. 1146: */ 1147: public void moveToFront() 1148: { 1149: Container p = getParent(); 1150: if (p != null && p instanceof JLayeredPane) 1151: ((JLayeredPane) p).moveToFront(this); 1152: } 1153: 1154: /** 1155: * This method causes the children of this JInternalFrame to be laid out. 1156: * Before it begins, if this JInternalFrame is an icon, then it will be 1157: * deiconified. If it is maximized, then it will be restored. If either 1158: * operation fails, then this method will return. 1159: */ 1160: public void pack() 1161: { 1162: try 1163: { 1164: if (isIcon()) 1165: setIcon(false); 1166: else if (isMaximum()) 1167: setMaximum(false); 1168: } 1169: catch (PropertyVetoException e) 1170: { 1171: // Do nothing if they don't want to be restored first. 1172: } 1173: setSize(getPreferredSize()); 1174: validate(); 1175: } 1176: 1177: /** 1178: * This method is overridden to allow for speedier painting while this 1179: * JInternalFramme is being dragged. 1180: * 1181: * @param g The Graphics object to paint with. 1182: */ 1183: protected void paintComponent(Graphics g) 1184: { 1185: super.paintComponent(g); 1186: } 1187: 1188: /** 1189: * An implementation dependent string describing the current state of this 1190: * <code>JInternalFrame</code> instance. 1191: * 1192: * @return A string describing the current state of this 1193: * <code>JInternalFrame</code> instance. 1194: */ 1195: protected String paramString() 1196: { 1197: return super.paramString() + ",title=" + getTitle(); 1198: } 1199: 1200: /** 1201: * This method removes the given Component from the Container. 1202: * 1203: * @param comp The Component to remove. 1204: */ 1205: public void remove(Component comp) 1206: { 1207: // If we're removing the root pane, use super.remove. Otherwise 1208: // pass it on to the content pane instead. 1209: if (comp==rootPane || ! isRootPaneCheckingEnabled()) 1210: super.remove(comp); 1211: else 1212: getContentPane().remove(comp); 1213: } 1214: 1215: /** 1216: * This method removes an InternalFrameListener from this JInternalFrame. 1217: * 1218: * @param l The listener to remove. 1219: */ 1220: public void removeInternalFrameListener(InternalFrameListener l) 1221: { 1222: listenerList.remove(InternalFrameListener.class, l); 1223: } 1224: 1225: /** 1226: * This method resizes and positions this JInternalFrame. It also forces a 1227: * relayout of the Container. 1228: * 1229: * @param x The x position of this JInternalFrame. 1230: * @param y The y position of this JInternalFrame. 1231: * @param width The width of this JInternalFrame. 1232: * @param height The height of this JInternalFrame. 1233: */ 1234: public void reshape(int x, int y, int width, int height) 1235: { 1236: super.reshape(x, y, width, height); 1237: revalidate(); 1238: } 1239: 1240: /** 1241: * This method gives focus to the last child Component that had focus. This 1242: * is used by the UI when this JInternalFrame is activated. 1243: */ 1244: public void restoreSubcomponentFocus() 1245: { 1246: Component c = getMostRecentFocusOwner(); 1247: if (c != null) 1248: c.requestFocus(); 1249: } 1250: 1251: /** 1252: * This method sets whether this JInternalFrame can be closed. 1253: * 1254: * @param b Whether this JInternalFrame can be closed. 1255: */ 1256: public void setClosable(boolean b) 1257: { 1258: if (closable != b) 1259: { 1260: closable = b; 1261: firePropertyChange("closable", ! closable, closable); 1262: } 1263: } 1264: 1265: /** 1266: * This method closes the JInternalFrame if the given boolean is true. If it 1267: * is false, then the result of this method is unspecified. If the 1268: * JInternalFrame is closed, this method does nothing. This method will 1269: * first fire an INTERNAL_FRAME_CLOSING event and give a chance for veto 1270: * listeners to cancel the close. If no listener vetoes the change, the 1271: * closed property is set to true and the JInternalFrame is hidden and 1272: * unselected. The method will finish by firing an INTERNAL_FRAME_CLOSED 1273: * event. 1274: * 1275: * @param b Whether the JInternalFrame will be closed. 1276: * 1277: * @throws PropertyVetoException If a VetoableChangeListener vetoes the change. 1278: */ 1279: public void setClosed(boolean b) throws PropertyVetoException 1280: { 1281: if (b && ! isClosed()) 1282: { 1283: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING); 1284: fireVetoableChange(IS_CLOSED_PROPERTY, false, true); 1285: 1286: isClosed = b; 1287: dispose(); 1288: 1289: firePropertyChange(IS_CLOSED_PROPERTY, false, true); 1290: } 1291: } 1292: 1293: /** 1294: * This method sets the Container to be used as a Content Pane for this 1295: * JInternalFrame. 1296: * 1297: * @param c The Container to use as a Content Pane. 1298: */ 1299: public void setContentPane(Container c) 1300: { 1301: if (c != getContentPane()) 1302: { 1303: Container old = getContentPane(); 1304: getRootPane().setContentPane(c); 1305: firePropertyChange(CONTENT_PANE_PROPERTY, old, c); 1306: } 1307: } 1308: 1309: /** 1310: * Sets a code for the action to be taken when this 1311: * <code>JInternalFrame</code> is closed. Note that no validation is 1312: * performed on the <code>operation</code> code, any integer will be 1313: * accepted (nevertheless, you should pass in one of the listed values). 1314: * 1315: * @param operation one of {@link WindowConstants#DO_NOTHING_ON_CLOSE}, 1316: * {@link WindowConstants#HIDE_ON_CLOSE} or 1317: * {@link WindowConstants#DISPOSE_ON_CLOSE}. 1318: * 1319: * @see #getDefaultCloseOperation() 1320: * @see #doDefaultCloseAction() 1321: */ 1322: public void setDefaultCloseOperation(int operation) 1323: { 1324: /* Reference implementation allows invalid operations to be specified. 1325: In that case, behaviour defaults to DO_NOTHING_ON_CLOSE. 1326: processWindowEvent handles the behaviour. getDefaultCloseOperation 1327: must return the invalid operator code. */ 1328: defaultCloseOperation = operation; 1329: } 1330: 1331: /** 1332: * Sets the <code>JDesktopIcon</code> instance that represents this 1333: * <code>JInternalFrame</code> while it is iconified and, if the new icon is 1334: * not the same instance as the existing icon, sends a 1335: * {@link PropertyChangeEvent} (with the property name 1336: * <code>"desktopIcon"</code>) to all registered listeners.. 1337: * 1338: * @param d the icon. 1339: * 1340: * @see #getDesktopIcon() 1341: */ 1342: public void setDesktopIcon(JDesktopIcon d) 1343: { 1344: if (desktopIcon != d) 1345: { 1346: JDesktopIcon oldIcon = desktopIcon; 1347: desktopIcon = d; 1348: firePropertyChange("desktopIcon", oldIcon, d); 1349: } 1350: } 1351: 1352: /** 1353: * This method does nothing because this must be the root of a focus 1354: * traversal cycle. 1355: * 1356: * @param focusCycleRoot Not used. 1357: */ 1358: public final void setFocusCycleRoot(boolean focusCycleRoot) 1359: { 1360: // Do nothing 1361: } 1362: 1363: /** 1364: * This method sets the Icon to be used in two places. The first is icon 1365: * that is painted at the top left corner of the JInternalFrame when it is 1366: * not iconified (clicking on that icon will activate the TitlePane 1367: * JMenuBar). When the JInternalFrame is iconified, it will be the icon 1368: * displayed in the JDesktopIcon. If no icon is set, the JInternalFrame 1369: * will use a Look and Feel default. 1370: * 1371: * @param icon The Icon used in the TitlePane JMenuBar and iconified frames. 1372: */ 1373: public void setFrameIcon(Icon icon) 1374: { 1375: if (icon != frameIcon) 1376: { 1377: Icon old = frameIcon; 1378: frameIcon = icon; 1379: firePropertyChange(FRAME_ICON_PROPERTY, old, frameIcon); 1380: } 1381: } 1382: 1383: /** 1384: * This method sets the Glass Pane used with this JInternalFrame. 1385: * 1386: * @param glass The Glass Pane to use with this JInternalFrame. 1387: */ 1388: public void setGlassPane(Component glass) 1389: { 1390: if (glass != getGlassPane()) 1391: { 1392: Component old = getGlassPane(); 1393: getRootPane().setGlassPane(glass); 1394: firePropertyChange(GLASS_PANE_PROPERTY, old, glass); 1395: } 1396: } 1397: 1398: /** 1399: * This method iconifies or deiconifies this JInternalFrame given the 1400: * boolean argument. If the JInternalFrame becomes iconified, it will fire 1401: * an INTERNAL_FRAME_ICONIFIED event. If the JInternalFrame becomes 1402: * deiconified, it will fire anINTERNAL_FRAME_DEICONIFIED event. 1403: * 1404: * @param b Whether this JInternalFrame is to be iconified or deiconified. 1405: * 1406: * @throws PropertyVetoException DOCUMENT ME! 1407: */ 1408: public void setIcon(boolean b) throws PropertyVetoException 1409: { 1410: if (b != isIcon()) 1411: { 1412: fireVetoableChange(IS_ICON_PROPERTY, b, isIcon); 1413: 1414: isIcon = b; 1415: 1416: firePropertyChange(IS_ICON_PROPERTY, ! isIcon, isIcon); 1417: if (b) 1418: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED); 1419: else 1420: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED); 1421: } 1422: } 1423: 1424: /** 1425: * This method sets whether the JInternalFrame can be iconified. (This means 1426: * that the JInternalFrame can be turned into an icon if minimized). 1427: * 1428: * @param b Whether the JInternalFrame can be iconified. 1429: */ 1430: public void setIconifiable(boolean b) 1431: { 1432: if (iconable != b) 1433: { 1434: iconable = b; 1435: firePropertyChange("iconable", ! iconable, iconable); 1436: } 1437: } 1438: 1439: /** 1440: * This method sets the JMenuBar to be used with this JInternalFrame. 1441: * 1442: * @param b The JMenuBar to be used with this JInternalFrame. 1443: */ 1444: public void setJMenuBar(JMenuBar b) 1445: { 1446: JMenuBar old = getJMenuBar(); 1447: getRootPane().setJMenuBar(b); 1448: firePropertyChange(MENU_BAR_PROPERTY, old, b); 1449: } 1450: 1451: /** 1452: * A helper method that set the layer that this JInternalFrame resides in. 1453: * Using this version of the method means that the user should not set it 1454: * to values that are already defined in JLayeredPane. If predefined values 1455: * are to be used, the user should use the setLayer(Integer) version. 1456: * 1457: * @param layer The layer to place this JInternalFrame in. 1458: */ 1459: public void setLayer(int layer) 1460: { 1461: setLayer(new Integer(layer)); 1462: } 1463: 1464: /** 1465: * A helper method that sets the layer that this JInternalFrame resides in. 1466: * Calling this version of the method should use layer values that are 1467: * already defined in JLayeredPane. 1468: * 1469: * @param layer The layer to place this JInternalFrame in. 1470: */ 1471: public void setLayer(Integer layer) 1472: { 1473: Container p = getParent(); 1474: if (p instanceof JLayeredPane) 1475: { 1476: JLayeredPane lp = (JLayeredPane) p; 1477: lp.setLayer(this, layer.intValue(), lp.getPosition(this)); 1478: } 1479: else 1480: { 1481: JLayeredPane.putLayer(this, layer.intValue()); 1482: if (p != null) 1483: p.repaint(getX(), getY(), getWidth(), getHeight()); 1484: } 1485: } 1486: 1487: /** 1488: * This method sets the JLayeredPane to use with this JInternalFrame. 1489: * 1490: * @param layered The JLayeredPane to use as a layeredPane. 1491: */ 1492: public void setLayeredPane(JLayeredPane layered) 1493: { 1494: if (layered == null) 1495: throw new IllegalComponentStateException("LayeredPane must not be null"); 1496: 1497: if (layered != getLayeredPane()) 1498: { 1499: JLayeredPane old = getLayeredPane(); 1500: getRootPane().setLayeredPane(layered); 1501: firePropertyChange(LAYERED_PANE_PROPERTY, old, layered); 1502: } 1503: } 1504: 1505: /** 1506: * This method sets whether the JInternalFrame can be maximized. 1507: * 1508: * @param b Whether this JInternalFrame can be maximized. 1509: */ 1510: public void setMaximizable(boolean b) 1511: { 1512: if (maximizable != b) 1513: { 1514: maximizable = b; 1515: firePropertyChange("maximizable", ! maximizable, maximizable); 1516: } 1517: } 1518: 1519: /** 1520: * This method sets the Layout Manager used in the JInternalFrame. SetLayout 1521: * should not be called on the JInternalFrame directly. Instead, it should 1522: * be called with JInternalFrame.getContentPane().setLayout. Calls to this 1523: * method with root pane checking enabled will cause exceptions to be 1524: * thrown. 1525: * 1526: * @param manager The Layout Manager to be used with the JInternalFrame. 1527: * 1528: * @throws Error If rootPaneChecking is enabled. 1529: */ 1530: public void setLayout(LayoutManager manager) 1531: { 1532: // Check if we're in initialization stage. If so, call super.setLayout 1533: // otherwise, valid calls go to the content pane. 1534: if (isRootPaneCheckingEnabled()) 1535: getContentPane().setLayout(manager); 1536: else 1537: super.setLayout(manager); 1538: } 1539: 1540: /** 1541: * This method sets the JInternalFrame to maximized (if the given argument 1542: * is true) or restores the JInternalFrame to its normal bounds otherwise. 1543: * 1544: * @param b Whether this JInteralFrame will be maximized or restored. 1545: * 1546: * @throws PropertyVetoException If a VetoableChangeListener vetoes the change. 1547: */ 1548: public void setMaximum(boolean b) throws PropertyVetoException 1549: { 1550: if (b != isMaximum) 1551: { 1552: fireVetoableChange(IS_MAXIMUM_PROPERTY, isMaximum, b); 1553: isMaximum = b; 1554: firePropertyChange(IS_MAXIMUM_PROPERTY, ! isMaximum, isMaximum); 1555: } 1556: } 1557: 1558: /** 1559: * This method is deprecated. This method sets the JMenuBar used with this 1560: * JInternalFrame. 1561: * 1562: * @param m The JMenuBar to use with this JInternalFrame. 1563: * 1564: * @deprecated 1.0.3 1565: */ 1566: public void setMenuBar(JMenuBar m) 1567: { 1568: setJMenuBar(m); 1569: } 1570: 1571: /** 1572: * This method sets the bounds that this JInternalFrame will be restored to. 1573: * 1574: * @param r The bounds that this JInternalFrame will be restored to. 1575: */ 1576: public void setNormalBounds(Rectangle r) 1577: { 1578: storedBounds = r; 1579: } 1580: 1581: /** 1582: * This method sets whether the JInternalFrame can be resized by a user 1583: * action (like dragging at the frame borders). 1584: * 1585: * @param b Whether this JInternalFramer can be resized. 1586: */ 1587: public void setResizable(boolean b) 1588: { 1589: if (b != resizable) 1590: { 1591: resizable = b; 1592: firePropertyChange("resizable", ! resizable, resizable); 1593: } 1594: } 1595: 1596: /** 1597: * This method sets the Root Pane for this JInternalFrame. 1598: * 1599: * @param root The Root Pane for this JInternalFrame. 1600: */ 1601: protected void setRootPane(JRootPane root) 1602: { 1603: if (rootPane != null) 1604: remove(rootPane); 1605: 1606: JRootPane old = rootPane; 1607: rootPane = root; 1608: 1609: if (rootPane != null) 1610: { 1611: boolean checkingEnabled = isRootPaneCheckingEnabled(); 1612: try 1613: { 1614: setRootPaneCheckingEnabled(false); 1615: add(rootPane, BorderLayout.CENTER); 1616: } 1617: finally 1618: { 1619: setRootPaneCheckingEnabled(checkingEnabled); 1620: } 1621: } 1622: firePropertyChange(ROOT_PANE_PROPERTY, old, rootPane); 1623: } 1624: 1625: /** 1626: * This method sets whether root pane checking is enabled. If root pane 1627: * checking is enabled, then calls to addImpl and setLayout will throw 1628: * exceptions. 1629: * 1630: * @param enabled Whether root pane checking is enabled. 1631: */ 1632: protected void setRootPaneCheckingEnabled(boolean enabled) 1633: { 1634: rootPaneCheckingEnabled = enabled; 1635: } 1636: 1637: /** 1638: * This method sets whether this JInternalFrame is the selected frame in the 1639: * JDesktopPane (or other container). When selected, a JInternalFrame will 1640: * have focus and paint its TitlePane differently (usually a different 1641: * colour). If this method selects the frame, this JInternalFrame will fire 1642: * an INTERNAL_FRAME_ACTIVATED event. If it deselects this frame, it will 1643: * fire an INTERNAL_FRAME_DEACTIVATED event. 1644: * 1645: * @param selected Whether this JInternalFrame will become selected or 1646: * deselected. 1647: * 1648: * @throws PropertyVetoException If a VetoableChangeListener vetoes the change. 1649: */ 1650: public void setSelected(boolean selected) throws PropertyVetoException 1651: { 1652: if (selected != isSelected 1653: && (! selected || (isIcon ? desktopIcon.isShowing() : isShowing()))) 1654: { 1655: fireVetoableChange(IS_SELECTED_PROPERTY, isSelected, selected); 1656: 1657: if (! selected) 1658: defaultFocus = getMostRecentFocusOwner(); 1659: 1660: isSelected = selected; 1661: firePropertyChange(IS_SELECTED_PROPERTY, ! isSelected, isSelected); 1662: 1663: if (isSelected) 1664: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED); 1665: else 1666: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED); 1667: 1668: if (selected) 1669: restoreSubcomponentFocus(); 1670: 1671: repaint(); 1672: } 1673: } 1674: 1675: /** 1676: * Sets the title for the <code>JInternalFrame</code> and sends a 1677: * {@link PropertyChangeEvent} (with the property name 1678: * {@link #TITLE_PROPERTY}) to all registered listeners. 1679: * 1680: * @param title the new title (<code>null</code> permitted). 1681: * 1682: * @see #getTitle() 1683: */ 1684: public void setTitle(String title) 1685: { 1686: String old = this.title; 1687: this.title = title; 1688: firePropertyChange(TITLE_PROPERTY, old, this.title); 1689: } 1690: 1691: /** 1692: * This method displays the JInternalFrame. If it is not visible, this 1693: * method will bring this JInternalFrame to the front, make it visible and 1694: * select it. If this is the first time this JInternalFrame is made 1695: * visible, an INTERNAL_FRAME_OPENED event will be fired. 1696: */ 1697: public void show() 1698: { 1699: if (! isVisible()) 1700: { 1701: if (isFirstTimeVisible) 1702: { 1703: isFirstTimeVisible = false; 1704: fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED); 1705: } 1706: 1707: getDesktopIcon().setVisible(true); 1708: 1709: toFront(); 1710: super.show(); 1711: 1712: if (isIcon()) 1713: return; 1714: 1715: if (! isSelected()) 1716: { 1717: try 1718: { 1719: setSelected(true); 1720: } 1721: catch (PropertyVetoException e) 1722: { 1723: // Do nothing. if they don't want to be selected. 1724: } 1725: } 1726: } 1727: } 1728: 1729: /** 1730: * This method is used to set the UI responsible for the JInternalFrame. 1731: * 1732: * @param ui The UI responsible for the JInternalFrame. 1733: */ 1734: public void setUI(InternalFrameUI ui) 1735: { 1736: // We must temporarily go into init mode so that the UI can directly 1737: // manipulate the JInternalFrame. 1738: boolean old = isRootPaneCheckingEnabled(); 1739: setRootPaneCheckingEnabled(false); 1740: super.setUI(ui); 1741: setRootPaneCheckingEnabled(old); 1742: } 1743: 1744: /** 1745: * This method causes the JInternalFrame to be brough to back in the 1746: * z-order. 1747: */ 1748: public void toBack() 1749: { 1750: moveToBack(); 1751: } 1752: 1753: /** 1754: * This method causes the JInternalFrame to be brought to front in the 1755: * z-order. 1756: */ 1757: public void toFront() 1758: { 1759: moveToFront(); 1760: } 1761: 1762: /** 1763: * This method resets the UI to the Look and Feel defaults. 1764: */ 1765: public void updateUI() 1766: { 1767: // We must go into the init stage when updating the UI, so the UI can 1768: // set layout and components directly on the internal frame, not its 1769: // content pane. 1770: boolean old = isRootPaneCheckingEnabled(); 1771: setRootPaneCheckingEnabled(false); 1772: setUI((InternalFrameUI) UIManager.getUI(this)); 1773: setRootPaneCheckingEnabled(old); 1774: } 1775: 1776: /** 1777: * This helper method allows JInternalFrames to signal that they were 1778: * iconned for the first time. 1779: * 1780: * @param b Whether the JInternalFrame was iconned. 1781: * @param ID The identifier of the property change event to fire if the 1782: * JInternalFrame is iconned for the first time. 1783: */ 1784: void setWasIcon(boolean b, String ID) 1785: { 1786: if (b && ! wasIcon) 1787: { 1788: wasIcon = b; 1789: firePropertyChange(ID, ! b, b); 1790: } 1791: } 1792: 1793: /** 1794: * This helper method returns whether the JInternalFrame has been iconned 1795: * once already. 1796: * 1797: * @return Whether the JInternalFrame has been iconned once already. 1798: */ 1799: boolean getWasIcon() 1800: { 1801: return wasIcon; 1802: } 1803: 1804: /** 1805: * This method is a convenience method to fire vetoable property changes. 1806: * 1807: * @param name The identifier of the property change. 1808: * @param oldValue The old value. 1809: * @param newValue The new value. 1810: * 1811: * @throws PropertyVetoException Fired if a vetoable change listener vetoes 1812: * the change. 1813: */ 1814: private void fireVetoableChange(String name, boolean oldValue, 1815: boolean newValue) 1816: throws PropertyVetoException 1817: { 1818: super.fireVetoableChange(name, Boolean.valueOf(oldValue), Boolean.valueOf(newValue)); 1819: } 1820: }