Window.java 25.9 KB
Newer Older
1
/* Window.java --
2
   Copyright (C) 1999, 2000, 2002, 2003, 2004  Free Software Foundation
3

4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
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. */
37

38

39
package java.awt;
40

Graydon Hoare committed
41
import java.awt.event.ComponentEvent;
Graydon Hoare committed
42 43
import java.awt.event.FocusEvent;
import java.awt.event.WindowAdapter;
44
import java.awt.event.WindowEvent;
45
import java.awt.event.WindowFocusListener;
46
import java.awt.event.WindowListener;
47
import java.awt.event.WindowStateListener;
48
import java.awt.peer.WindowPeer;
49 50
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
51
import java.util.EventListener;
52
import java.util.Iterator;
53
import java.util.Locale;
54
import java.util.ResourceBundle;
55
import java.util.Vector;
56

57 58
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
Graydon Hoare committed
59 60 61
import javax.accessibility.AccessibleRole;
import javax.accessibility.AccessibleState;
import javax.accessibility.AccessibleStateSet;
62

63 64 65
/**
 * This class represents a top-level window with no decorations.
 *
66 67
 * @author Aaron M. Renn (arenn@urbanophile.com)
 * @author Warren Levy  (warrenl@cygnus.com)
68
 */
69
public class Window extends Container implements Accessible
70
{
71 72
  private static final long serialVersionUID = 4497834738069338734L;

73 74 75
  // Serialized fields, from Sun's serialization spec.
  private String warningString = null;
  private int windowSerializedDataVersion = 0; // FIXME
76 77 78 79 80 81
  /** @since 1.2 */
  // private FocusManager focusMgr;  // FIXME: what is this?  
  /** @since 1.2 */
  private int state = 0;
  /** @since 1.4 */
  private boolean focusableWindowState = true;
82

83 84 85
  // A list of other top-level windows owned by this window.
  private transient Vector ownedWindows = new Vector();

86
  private transient WindowListener windowListener;
87 88
  private transient WindowFocusListener windowFocusListener;
  private transient WindowStateListener windowStateListener;
89 90
  private transient GraphicsConfiguration graphicsConfiguration;

Graydon Hoare committed
91 92
  private transient boolean shown;

Graydon Hoare committed
93
  private transient Component windowFocusOwner;
Graydon Hoare committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
  
  protected class AccessibleAWTWindow extends AccessibleAWTContainer
  {
    public AccessibleRole getAccessibleRole()
    {
      return AccessibleRole.WINDOW;
    }
    
    public AccessibleStateSet getAccessibleStateSet()
    {
      AccessibleStateSet states = super.getAccessibleStateSet();
      if (isActive())
        states.add(AccessibleState.ACTIVE);
      return states;
    }
  }
Graydon Hoare committed
110

111 112 113 114 115 116 117 118
  /** 
   * This (package access) constructor is used by subclasses that want
   * to build windows that do not have parents.  Eg. toplevel
   * application frames.  Subclasses cannot call super(null), since
   * null is an illegal argument.
   */
  Window()
  {
119
    visible = false;
Graydon Hoare committed
120 121 122
    // Windows are the only Containers that default to being focus
    // cycle roots.
    focusCycleRoot = true;
123
    setLayout(new BorderLayout());
Graydon Hoare committed
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150

    addWindowFocusListener (new WindowAdapter ()
      {
        public void windowGainedFocus (WindowEvent event)
        {
          if (windowFocusOwner != null)
            {
              // FIXME: move this section and the other similar
              // sections in Component into a separate method.
              EventQueue eq = Toolkit.getDefaultToolkit ().getSystemEventQueue ();
              synchronized (eq)
                {
                  KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager ();
                  Component currentFocusOwner = manager.getGlobalPermanentFocusOwner ();
                  if (currentFocusOwner != null)
                    {
                      eq.postEvent (new FocusEvent (currentFocusOwner, FocusEvent.FOCUS_LOST,
                                                    false, windowFocusOwner));
                      eq.postEvent (new FocusEvent (windowFocusOwner, FocusEvent.FOCUS_GAINED,
                                                    false, currentFocusOwner));
                    }
                  else
                    eq.postEvent (new FocusEvent (windowFocusOwner, FocusEvent.FOCUS_GAINED, false));
                }
            }
        }
      });
151 152 153 154 155 156 157
  }

  Window(GraphicsConfiguration gc)
  {
    this();
    graphicsConfiguration = gc;
  }
158

159 160 161 162
  /**
   * Initializes a new instance of <code>Window</code> with the specified
   * parent.  The window will initially be invisible.
   *
163
   * @param owner The owning <code>Frame</code> of this window.
164 165 166 167
   *
   * @exception IllegalArgumentException If the owner's GraphicsConfiguration
   * is not from a screen device, or if owner is null; this exception is always
   * thrown when GraphicsEnvironment.isHeadless returns true.
168
   */
169 170
  public Window(Frame owner)
  {
171
    this (owner, owner.getGraphicsConfiguration ());
172 173
  }

174 175 176 177 178 179 180 181 182 183
  /**
   * Initializes a new instance of <code>Window</code> with the specified
   * parent.  The window will initially be invisible.   
   *
   * @exception IllegalArgumentException If the owner's GraphicsConfiguration
   * is not from a screen device, or if owner is null; this exception is always
   * thrown when GraphicsEnvironment.isHeadless returns true.
   *
   * @since 1.2
   */
184
  public Window(Window owner)
185
  {
186
    this (owner, owner.getGraphicsConfiguration ());
187 188
  }
  
189 190 191 192 193 194 195 196 197 198
  /**
   * Initializes a new instance of <code>Window</code> with the specified
   * parent.  The window will initially be invisible.   
   *
   * @exception IllegalArgumentException If owner is null or if gc is not from a
   * screen device; this exception is always thrown when
   * GraphicsEnvironment.isHeadless returns true.
   *
   * @since 1.3
   */
199 200
  public Window(Window owner, GraphicsConfiguration gc)
  {
201
    this ();
202

203
    synchronized (getTreeLock())
204
      {
205 206 207 208
	if (owner == null)
	  throw new IllegalArgumentException ("owner must not be null");

	parent = owner;
209 210 211
        owner.ownedWindows.add(new WeakReference(this));
      }

212 213 214 215
    // FIXME: make this text visible in the window.
    SecurityManager s = System.getSecurityManager();
    if (s != null && ! s.checkTopLevelWindow(this))
      warningString = System.getProperty("awt.appletWarning");
216 217 218 219 220

    if (gc != null
        && gc.getDevice().getType() != GraphicsDevice.TYPE_RASTER_SCREEN)
      throw new IllegalArgumentException ("gc must be from a screen device");

Graydon Hoare committed
221 222 223 224 225
    if (gc == null)
      graphicsConfiguration = GraphicsEnvironment.getLocalGraphicsEnvironment()
                                                 .getDefaultScreenDevice()
                                                 .getDefaultConfiguration();
    else
226
      graphicsConfiguration = gc;
227
  }
228

229 230 231 232 233 234
  GraphicsConfiguration getGraphicsConfigurationImpl()
  {
    if (graphicsConfiguration != null)
	return graphicsConfiguration;

    return super.getGraphicsConfigurationImpl();
235 236
  }

237
  /**
238 239
   * Creates the native peer for this window.
   */
240
  public void addNotify()
241 242
  {
    if (peer == null)
243 244
      peer = getToolkit().createWindow(this);
    super.addNotify();
245
  }
246

247 248 249 250 251 252
  /**
   * Relays out this window's child components at their preferred size.
   *
   * @specnote pack() doesn't appear to be called internally by show(), so
   *             we duplicate some of the functionality.
   */
253
  public void pack()
254
  {
255
    if (parent != null && !parent.isDisplayable())
256
      parent.addNotify();
257
    if (peer == null)
258
      addNotify();
259 260

    setSize(getPreferredSize());
261

262 263 264
    validate();
  }

265
  /**
266 267
   * Shows on-screen this window and any of its owned windows for whom
   * isVisible returns true.
268
   */
269
  public void show()
270
  {
271 272
    if (parent != null && !parent.isDisplayable())
      parent.addNotify();
273 274
    if (peer == null)
      addNotify();
275

276
    // Show visible owned windows.
277
    synchronized (getTreeLock())
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
      {
	Iterator e = ownedWindows.iterator();
	while(e.hasNext())
	  {
	    Window w = (Window)(((Reference) e.next()).get());
	    if (w != null)
	      {
		if (w.isVisible())
		  w.getPeer().setVisible(true);
	      }
     	    else
	      // Remove null weak reference from ownedWindows.
	      // Unfortunately this can't be done in the Window's
	      // finalize method because there is no way to guarantee
	      // synchronous access to ownedWindows there.
	      e.remove();
	  }
      }
296
    validate();
297
    super.show();
298
    toFront();
Graydon Hoare committed
299 300 301 302 303 304 305 306 307 308 309 310 311

    KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager ();
    manager.setGlobalFocusedWindow (this);

    if (!shown)
      {
        FocusTraversalPolicy policy = getFocusTraversalPolicy ();
        Component initialFocusOwner = null;

        if (policy != null)
          initialFocusOwner = policy.getInitialComponent (this);

        if (initialFocusOwner != null)
312
          initialFocusOwner.requestFocusInWindow ();
Graydon Hoare committed
313 314 315

        shown = true;
      }
316 317 318 319
  }

  public void hide()
  {
320
    // Hide visible owned windows.
321
    synchronized (getTreeLock ())
322 323 324 325 326 327
      {
	Iterator e = ownedWindows.iterator();
	while(e.hasNext())
	  {
	    Window w = (Window)(((Reference) e.next()).get());
	    if (w != null)
328 329 330 331
	      {
		if (w.isVisible() && w.getPeer() != null)
		  w.getPeer().setVisible(false);
	      }
332 333 334 335
     	    else
	      e.remove();
	  }
      }
336
    super.hide();
337 338
  }

339 340 341 342 343 344 345
  public boolean isDisplayable()
  {
    if (super.isDisplayable())
      return true;
    return peer != null;
  }

346
  /**
347 348
   * Destroys any resources associated with this window.  This includes
   * all components in the window and all owned top-level windows.
349
   */
350 351
  public void dispose()
  {
352 353
    hide();

354
    synchronized (getTreeLock ())
355 356 357 358 359 360 361 362 363 364 365
      {
	Iterator e = ownedWindows.iterator();
	while(e.hasNext())
	  {
	    Window w = (Window)(((Reference) e.next()).get());
	    if (w != null)
	      w.dispose();
	    else
	      // Remove null weak reference from ownedWindows.
	      e.remove();
	  }
366

367 368 369 370 371 372 373 374
	for (int i = 0; i < ncomponents; ++i)
	  component[i].removeNotify();
	this.removeNotify();

        // Post a WINDOW_CLOSED event.
        WindowEvent we = new WindowEvent(this, WindowEvent.WINDOW_CLOSED);
        getToolkit().getSystemEventQueue().postEvent(we);
      }
375 376
  }

377 378 379 380
  /**
   * Sends this window to the back so that all other windows display in
   * front of it.
   */
381
  public void toBack()
382
  {
383 384 385
    if (peer != null)
      {
	WindowPeer wp = (WindowPeer) peer;
386
	wp.toBack();
387
      }
388 389
  }

390 391 392 393
  /**
   * Brings this window to the front so that it displays in front of
   * any other windows.
   */
394
  public void toFront()
395
  {
396 397
    if (peer != null)
      {
398 399
        WindowPeer wp = (WindowPeer) peer;
        wp.toFront();
400 401 402
      }
  }

403 404 405 406 407 408 409 410
  /**
   * Returns the toolkit used to create this window.
   *
   * @return The toolkit used to create this window.
   *
   * @specnote Unlike Component.getToolkit, this implementation always 
   *           returns the value of Toolkit.getDefaultToolkit().
   */
411 412
  public Toolkit getToolkit()
  {
413
    return Toolkit.getDefaultToolkit();    
414 415
  }

416 417 418 419 420 421
  /**
   * Returns the warning string that will be displayed if this window is
   * popped up by an unsecure applet or application.
   *
   * @return The unsecure window warning message.
   */
422 423
  public final String getWarningString()
  {
424
    return warningString;
425
  }
426

427 428 429 430 431
  /**
   * Returns the locale that this window is configured for.
   *
   * @return The locale this window is configured for.
   */
432
  public Locale getLocale()
433
  {
434
    return locale == null ? Locale.getDefault() : locale;
435 436
  }

437 438 439
  /*
  /** @since 1.2
  public InputContext getInputContext()
440
  {
441
    // FIXME
442
  }
443
  */
444

445 446 447 448 449
  /**
   * Sets the cursor for this window to the specifiec cursor.
   *
   * @param cursor The new cursor for this window.
   */
450
  public void setCursor(Cursor cursor)
451
  {
452 453 454 455 456
    super.setCursor(cursor);
  }

  public Window getOwner()
  {
457
    return (Window) parent;
458 459
  }

460 461
  /** @since 1.2 */
  public Window[] getOwnedWindows()
462
  {
463
    Window [] trimmedList;
464
    synchronized (getTreeLock ())
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
      {
	// Windows with non-null weak references in ownedWindows.
	Window [] validList = new Window [ownedWindows.size()];

	Iterator e = ownedWindows.iterator();
	int numValid = 0;
	while (e.hasNext())
	  {
	    Window w = (Window)(((Reference) e.next()).get());
	    if (w != null)
	      validList[numValid++] = w;
	    else
	      // Remove null weak reference from ownedWindows.
	      e.remove();
	  }

	if (numValid != validList.length)
	  {
	    trimmedList = new Window [numValid];
	    System.arraycopy (validList, 0, trimmedList, 0, numValid);
	  }
	else
	  trimmedList = validList;
      }
    return trimmedList;
490 491
  }

492 493 494 495 496 497
  /**
   * Adds the specified listener to the list of <code>WindowListeners</code>
   * that will receive events for this window.
   *
   * @param listener The <code>WindowListener</code> to add.
   */
498
  public synchronized void addWindowListener(WindowListener listener)
499
  {
500
    windowListener = AWTEventMulticaster.add(windowListener, listener);
501 502
  }

503 504 505 506 507 508
  /**
   * Removes the specified listener from the list of
   * <code>WindowListeners</code> that will receive events for this window.
   *
   * @param listener The <code>WindowListener</code> to remove.
   */
509 510 511 512 513
  public synchronized void removeWindowListener(WindowListener listener)
  {
    windowListener = AWTEventMulticaster.remove(windowListener, listener);
  }

514 515 516 517 518
  /**
   * Returns an array of all the window listeners registered on this window.
   *
   * @since 1.4
   */
519
  public synchronized WindowListener[] getWindowListeners()
520
  {
521 522 523
    return (WindowListener[])
      AWTEventMulticaster.getListeners(windowListener,
                                       WindowListener.class);
524 525
  }

526
  /**
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
   * Returns an array of all the window focus listeners registered on this
   * window.
   *
   * @since 1.4
   */
  public synchronized WindowFocusListener[] getWindowFocusListeners()
  {
    return (WindowFocusListener[])
      AWTEventMulticaster.getListeners(windowFocusListener,
                                       WindowFocusListener.class);
  }
  
  /**
   * Returns an array of all the window state listeners registered on this
   * window.
   *
   * @since 1.4
   */
  public synchronized WindowStateListener[] getWindowStateListeners()
  {
    return (WindowStateListener[])
      AWTEventMulticaster.getListeners(windowStateListener,
                                       WindowStateListener.class);
  }

  /**
   * Adds the specified listener to this window.
   */
  public void addWindowFocusListener (WindowFocusListener wfl)
  {
557
    windowFocusListener = AWTEventMulticaster.add (windowFocusListener, wfl);
558 559 560 561 562 563 564 565 566
  }
  
  /**
   * Adds the specified listener to this window.
   *
   * @since 1.4
   */
  public void addWindowStateListener (WindowStateListener wsl)
  {
567
    windowStateListener = AWTEventMulticaster.add (windowStateListener, wsl);  
568 569 570 571 572 573 574
  }
  
  /**
   * Removes the specified listener from this window.
   */
  public void removeWindowFocusListener (WindowFocusListener wfl)
  {
575
    windowFocusListener = AWTEventMulticaster.remove (windowFocusListener, wfl);
576 577 578 579 580 581 582 583 584
  }
  
  /**
   * Removes the specified listener from this window.
   *
   * @since 1.4
   */
  public void removeWindowStateListener (WindowStateListener wsl)
  {
585
    windowStateListener = AWTEventMulticaster.remove (windowStateListener, wsl);
586 587 588
  }

  /**
589 590 591 592 593 594 595 596 597
   * Returns an array of all the objects currently registered as FooListeners
   * upon this Window. FooListeners are registered using the addFooListener
   * method.
   *
   * @exception ClassCastException If listenerType doesn't specify a class or
   * interface that implements java.util.EventListener.
   *
   * @since 1.3
   */
598 599 600
  public EventListener[] getListeners(Class listenerType)
  {
    if (listenerType == WindowListener.class)
601 602
      return getWindowListeners();
    return super.getListeners(listenerType);
603 604 605 606 607 608 609
  }

  void dispatchEventImpl(AWTEvent e)
  {
    // Make use of event id's in order to avoid multiple instanceof tests.
    if (e.id <= WindowEvent.WINDOW_LAST 
        && e.id >= WindowEvent.WINDOW_FIRST
610 611 612
        && (windowListener != null
	    || windowFocusListener != null
	    || windowStateListener != null
613 614 615 616
	    || (eventMask & AWTEvent.WINDOW_EVENT_MASK) != 0))
      processEvent(e);
    else
      super.dispatchEventImpl(e);
617 618
  }

619 620 621 622 623 624
  /**
   * Processes the specified event for this window.  If the event is an
   * instance of <code>WindowEvent</code>, then
   * <code>processWindowEvent()</code> is called to process the event,
   * otherwise the superclass version of this method is invoked.
   *
625
   * @param evt The event to process.
626
   */
627
  protected void processEvent(AWTEvent evt)
628 629
  {
    if (evt instanceof WindowEvent)
630
      processWindowEvent((WindowEvent) evt);
631
    else
632
      super.processEvent(evt);
633 634
  }

635 636 637 638 639 640
  /**
   * Dispatches this event to any listeners that are listening for
   * <code>WindowEvents</code> on this window.  This method only gets
   * invoked if it is enabled via <code>enableEvents()</code> or if
   * a listener has been added.
   *
641
   * @param evt The event to process.
642
   */
643
  protected void processWindowEvent(WindowEvent evt)
644
  {
645 646 647 648 649 650 651 652
    int id = evt.getID();

    if (id == WindowEvent.WINDOW_GAINED_FOCUS
	|| id == WindowEvent.WINDOW_LOST_FOCUS)
      processWindowFocusEvent (evt);
    else if (id == WindowEvent.WINDOW_STATE_CHANGED)
      processWindowStateEvent (evt);
    else
653
      {
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
	if (windowListener != null)
	  {
	    switch (evt.getID())
	      {
	      case WindowEvent.WINDOW_ACTIVATED:
		windowListener.windowActivated(evt);
		break;

	      case WindowEvent.WINDOW_CLOSED:
		windowListener.windowClosed(evt);
		break;

	      case WindowEvent.WINDOW_CLOSING:
		windowListener.windowClosing(evt);
		break;

	      case WindowEvent.WINDOW_DEACTIVATED:
		windowListener.windowDeactivated(evt);
		break;

	      case WindowEvent.WINDOW_DEICONIFIED:
		windowListener.windowDeiconified(evt);
		break;

	      case WindowEvent.WINDOW_ICONIFIED:
		windowListener.windowIconified(evt);
		break;

	      case WindowEvent.WINDOW_OPENED:
		windowListener.windowOpened(evt);
		break;

	      default:
		break;
	      }
	  }
690 691
      }
  }
Graydon Hoare committed
692 693 694 695 696 697 698 699 700 701 702 703 704
  
  /**
   * Identifies if this window is active.  The active window is a Frame or
   * Dialog that has focus or owns the active window.
   *  
   * @return true if active, else false.
   * @since 1.4
   */
  public boolean isActive()
  {
    KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager ();
    return manager.getActiveWindow() == this;
  }
705

706
  /**
Graydon Hoare committed
707 708 709 710 711 712 713 714 715 716 717 718 719
   * Identifies if this window is focused.  A window is focused if it is the
   * focus owner or it contains the focus owner.
   * 
   * @return true if focused, else false.
   * @since 1.4
   */
  public boolean isFocused()
  {
    KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager ();
    return manager.getFocusedWindow() == this;
  }
  
  /**
720 721 722 723 724 725 726
   * Returns the child window that has focus if this window is active.
   * This method returns <code>null</code> if this window is not active
   * or no children have focus.
   *
   * @return The component that has focus, or <code>null</code> if no
   * component has focus.
   */
Graydon Hoare committed
727
  public Component getFocusOwner ()
728
  {
Graydon Hoare committed
729 730 731 732 733 734 735
    KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager ();

    Window activeWindow = manager.getActiveWindow ();

    // The currently-focused Component belongs to the active Window.
    if (activeWindow == this)
      return manager.getFocusOwner ();
Graydon Hoare committed
736 737 738
    else
      return windowFocusOwner;
  }
Graydon Hoare committed
739

Graydon Hoare committed
740 741 742 743 744 745 746 747 748 749 750 751
  /**
   * Set the focus owner for this window.  This method is used to
   * remember which component was focused when this window lost
   * top-level focus, so that when it regains top-level focus the same
   * child component can be refocused.
   *
   * @param windowFocusOwner the component in this window that owns
   * the focus.
   */
  void setFocusOwner (Component windowFocusOwner)
  {
    this.windowFocusOwner = windowFocusOwner;
752
  }
753

754 755 756
  /**
   * Post a Java 1.0 event to the event queue.
   *
757
   * @param e The event to post.
758 759
   *
   * @deprecated
760
   */
761
  public boolean postEvent(Event e)
762
  {
Graydon Hoare committed
763
    return handleEvent (e);
764 765
  }

766 767 768 769 770 771
  /**
   * Tests whether or not this window is visible on the screen.
   *
   * @return <code>true</code> if this window is visible, <code>false</code>
   * otherwise.
   */
772
  public boolean isShowing()
773
  {
774
    return super.isShowing();
775
  }
776

Graydon Hoare committed
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
  public void setLocationRelativeTo (Component c)
  {
    if (c == null || !c.isShowing ())
      {
        int x = 0;
        int y = 0;

        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment ();
        Point center = ge.getCenterPoint ();
        x = center.x - (width / 2);
        y = center.y - (height / 2);
        setLocation (x, y);
      }
    // FIXME: handle case where component is non-null.
  }

793 794 795 796 797
  /**
   * @since 1.2
   *
   * @deprecated
   */
798
  public void applyResourceBundle(ResourceBundle rb)
799
  {
800
    throw new Error ("Not implemented");
801 802
  }

803 804 805 806 807
  /**
   * @since 1.2
   *
   * @deprecated
   */
808 809
  public void applyResourceBundle(String rbName)
  {
810
    ResourceBundle rb = ResourceBundle.getBundle(rbName, Locale.getDefault(),
811
      ClassLoader.getSystemClassLoader());
812 813 814
    if (rb != null)
      applyResourceBundle(rb);    
  }
815

Graydon Hoare committed
816 817 818 819 820 821
  /**
   * Gets the AccessibleContext associated with this <code>Window</code>.
   * The context is created, if necessary.
   *
   * @return the associated context
   */
822 823
  public AccessibleContext getAccessibleContext()
  {
Graydon Hoare committed
824 825 826 827
    /* Create the context if this is the first request */
    if (accessibleContext == null)
      accessibleContext = new AccessibleAWTWindow();
    return accessibleContext;
828 829
  }

830 831 832 833 834
  /** 
   * Get graphics configuration.  The implementation for Window will
   * not ask any parent containers, since Window is a toplevel
   * window and not actually embedded in the parent component.
   */
835 836
  public GraphicsConfiguration getGraphicsConfiguration()
  {
837 838 839
    if (graphicsConfiguration != null) return graphicsConfiguration;
    if (peer != null) return peer.getGraphicsConfiguration();
    return null;
840
  }
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870

  protected void processWindowFocusEvent(WindowEvent event)
  {
    if (windowFocusListener != null)
      {
        switch (event.getID ())
          {
          case WindowEvent.WINDOW_GAINED_FOCUS:
            windowFocusListener.windowGainedFocus (event);
            break;
            
          case WindowEvent.WINDOW_LOST_FOCUS:
            windowFocusListener.windowLostFocus (event);
            break;
            
          default:
            break;
          }
      }
  }
  
  /**
   * @since 1.4
   */
  protected void processWindowStateEvent(WindowEvent event)
  {
    if (windowStateListener != null
        && event.getID () == WindowEvent.WINDOW_STATE_CHANGED)
      windowStateListener.windowStateChanged (event);
  }
871 872 873 874 875 876

  /**
   * Returns whether this <code>Window</code> can get the focus or not.
   *
   * @since 1.4
   */
877
  public final boolean isFocusableWindow ()
878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909
  {
    if (getFocusableWindowState () == false)
      return false;

    if (this instanceof Dialog
        || this instanceof Frame)
      return true;

    // FIXME: Implement more possible cases for returning true.

    return false;
  }
  
  /**
   * Returns the value of the focusableWindowState property.
   * 
   * @since 1.4
   */
  public boolean getFocusableWindowState ()
  {
    return focusableWindowState;
  }

  /**
   * Sets the value of the focusableWindowState property.
   * 
   * @since 1.4
   */
  public void setFocusableWindowState (boolean focusableWindowState)
  {
    this.focusableWindowState = focusableWindowState;
  }
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928

  // setBoundsCallback is needed so that when a user moves a window,
  // the Window's location can be updated without calling the peer's
  // setBounds method.  When a user moves a window the peer window's
  // location is updated automatically and the windowing system sends
  // a message back to the application informing it of its updated
  // dimensions.  We must update the AWT Window class with these new
  // dimensions.  But we don't want to call the peer's setBounds
  // method, because the peer's dimensions have already been updated.
  // (Under X, having this method prevents Configure event loops when
  // moving windows: Component.setBounds -> peer.setBounds ->
  // postConfigureEvent -> Component.setBounds -> ...  In some cases
  // Configure event loops cause windows to jitter back and forth
  // continuously).
  void setBoundsCallback (int x, int y, int w, int h)
  {
    if (this.x == x && this.y == y && width == w && height == h)
      return;
    invalidate();
Graydon Hoare committed
929 930
    boolean resized = width != w || height != h;
    boolean moved = this.x != x || this.y != y;
931 932 933 934
    this.x = x;
    this.y = y;
    width = w;
    height = h;
Graydon Hoare committed
935
    if (resized && isShowing ())
Graydon Hoare committed
936 937 938 939 940
      {
        ComponentEvent ce =
          new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED);
        getToolkit().getSystemEventQueue().postEvent(ce);
      }
Graydon Hoare committed
941
    if (moved && isShowing ())
Graydon Hoare committed
942 943 944 945 946
      {
        ComponentEvent ce =
          new ComponentEvent(this, ComponentEvent.COMPONENT_MOVED);
        getToolkit().getSystemEventQueue().postEvent(ce);
      }
947
  }
948
}