300 lines
9.4 KiB
Diff
300 lines
9.4 KiB
Diff
diff -Nru gcc-4.0.2.orig/libjava/java/awt/Window.java gcc-4.0.2/libjava/java/awt/Window.java
|
|
--- gcc-4.0.2.orig/libjava/java/awt/Window.java 2005-10-25 12:54:05.000000000 +0200
|
|
+++ gcc-4.0.2/libjava/java/awt/Window.java 2005-10-25 16:19:42.000000000 +0200
|
|
@@ -15,8 +15,8 @@
|
|
|
|
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.
|
|
+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
|
|
@@ -45,6 +45,7 @@
|
|
import java.awt.event.WindowFocusListener;
|
|
import java.awt.event.WindowListener;
|
|
import java.awt.event.WindowStateListener;
|
|
+import java.awt.image.BufferStrategy;
|
|
import java.awt.peer.WindowPeer;
|
|
import java.lang.ref.Reference;
|
|
import java.lang.ref.WeakReference;
|
|
@@ -90,7 +91,8 @@
|
|
|
|
private transient boolean shown;
|
|
|
|
- private transient Component windowFocusOwner;
|
|
+ // This is package-private to avoid an accessor method.
|
|
+ transient Component windowFocusOwner;
|
|
|
|
/*
|
|
* The number used to generate the name returned by getName.
|
|
@@ -153,6 +155,9 @@
|
|
}
|
|
}
|
|
});
|
|
+
|
|
+ GraphicsEnvironment g = GraphicsEnvironment.getLocalGraphicsEnvironment();
|
|
+ graphicsConfiguration = g.getDefaultScreenDevice().getDefaultConfiguration();
|
|
}
|
|
|
|
Window(GraphicsConfiguration gc)
|
|
@@ -617,6 +622,8 @@
|
|
|| windowStateListener != null
|
|
|| (eventMask & AWTEvent.WINDOW_EVENT_MASK) != 0))
|
|
processEvent(e);
|
|
+ else if (e.id == ComponentEvent.COMPONENT_RESIZED)
|
|
+ validate ();
|
|
else
|
|
super.dispatchEventImpl(e);
|
|
}
|
|
@@ -739,7 +746,25 @@
|
|
if (activeWindow == this)
|
|
return manager.getFocusOwner ();
|
|
else
|
|
- return windowFocusOwner;
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * Returns the child component of this window that would receive
|
|
+ * focus if this window were to become focused. If the window
|
|
+ * already has the top-level focus, then this method returns the
|
|
+ * same component as getFocusOwner. If no child component has
|
|
+ * requested focus within the window, then the initial focus owner
|
|
+ * is returned. If this is a non-focusable window, this method
|
|
+ * returns null.
|
|
+ *
|
|
+ * @return the child component of this window that most recently had
|
|
+ * the focus, or <code>null</code>
|
|
+ * @since 1.4
|
|
+ */
|
|
+ public Component getMostRecentFocusOwner ()
|
|
+ {
|
|
+ return windowFocusOwner;
|
|
}
|
|
|
|
/**
|
|
@@ -771,12 +796,16 @@
|
|
/**
|
|
* Tests whether or not this window is visible on the screen.
|
|
*
|
|
+ * In contrast to the normal behaviour of Container, which is that
|
|
+ * a container is showing if its parent is visible and showing, a Window
|
|
+ * is even showing, if its parent (i.e. an invisible Frame) is not showing.
|
|
+ *
|
|
* @return <code>true</code> if this window is visible, <code>false</code>
|
|
* otherwise.
|
|
*/
|
|
public boolean isShowing()
|
|
{
|
|
- return super.isShowing();
|
|
+ return isVisible();
|
|
}
|
|
|
|
public void setLocationRelativeTo (Component c)
|
|
@@ -796,6 +825,157 @@
|
|
}
|
|
|
|
/**
|
|
+ * A BltBufferStrategy for windows.
|
|
+ */
|
|
+ private class WindowBltBufferStrategy extends BltBufferStrategy
|
|
+ {
|
|
+ /**
|
|
+ * Creates a block transfer strategy for this window.
|
|
+ *
|
|
+ * @param numBuffers the number of buffers in this strategy
|
|
+ * @param accelerated true if the buffer should be accelerated,
|
|
+ * false otherwise
|
|
+ */
|
|
+ WindowBltBufferStrategy(int numBuffers, boolean accelerated)
|
|
+ {
|
|
+ super(numBuffers,
|
|
+ new BufferCapabilities(new ImageCapabilities(accelerated),
|
|
+ new ImageCapabilities(accelerated),
|
|
+ BufferCapabilities.FlipContents.COPIED));
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * A FlipBufferStrategy for windows.
|
|
+ */
|
|
+ private class WindowFlipBufferStrategy extends FlipBufferStrategy
|
|
+ {
|
|
+ /**
|
|
+ * Creates a flip buffer strategy for this window.
|
|
+ *
|
|
+ * @param numBuffers the number of buffers in this strategy
|
|
+ *
|
|
+ * @throws AWTException if the requested number of buffers is not
|
|
+ * supported
|
|
+ */
|
|
+ WindowFlipBufferStrategy(int numBuffers)
|
|
+ throws AWTException
|
|
+ {
|
|
+ super(numBuffers,
|
|
+ new BufferCapabilities(new ImageCapabilities(true),
|
|
+ new ImageCapabilities(true),
|
|
+ BufferCapabilities.FlipContents.COPIED));
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * Creates a buffering strategy that manages how this window is
|
|
+ * repainted. This method attempts to create the optimum strategy
|
|
+ * based on the desired number of buffers. Hardware or software
|
|
+ * acceleration may be used.
|
|
+ *
|
|
+ * createBufferStrategy attempts different levels of optimization,
|
|
+ * but guarantees that some strategy with the requested number of
|
|
+ * buffers will be created even if it is not optimal. First it
|
|
+ * attempts to create a page flipping strategy, then an accelerated
|
|
+ * blitting strategy, then an unaccelerated blitting strategy.
|
|
+ *
|
|
+ * Calling this method causes any existing buffer strategy to be
|
|
+ * destroyed.
|
|
+ *
|
|
+ * @param numBuffers the number of buffers in this strategy
|
|
+ *
|
|
+ * @throws IllegalArgumentException if requested number of buffers
|
|
+ * is less than one
|
|
+ * @throws IllegalStateException if this window is not displayable
|
|
+ *
|
|
+ * @since 1.4
|
|
+ */
|
|
+ public void createBufferStrategy(int numBuffers)
|
|
+ {
|
|
+ if (numBuffers < 1)
|
|
+ throw new IllegalArgumentException("Window.createBufferStrategy: number"
|
|
+ + " of buffers is less than one");
|
|
+
|
|
+ if (!isDisplayable())
|
|
+ throw new IllegalStateException("Window.createBufferStrategy: window is"
|
|
+ + " not displayable");
|
|
+
|
|
+ BufferStrategy newStrategy = null;
|
|
+
|
|
+ // try a flipping strategy
|
|
+ try
|
|
+ {
|
|
+ newStrategy = new WindowFlipBufferStrategy(numBuffers);
|
|
+ }
|
|
+ catch (AWTException e)
|
|
+ {
|
|
+ }
|
|
+
|
|
+ // fall back to an accelerated blitting strategy
|
|
+ if (newStrategy == null)
|
|
+ newStrategy = new WindowBltBufferStrategy(numBuffers, true);
|
|
+
|
|
+ bufferStrategy = newStrategy;
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * Creates a buffering strategy that manages how this window is
|
|
+ * repainted. This method attempts to create a strategy based on
|
|
+ * the specified capabilities and throws an exception if the
|
|
+ * requested strategy is not supported.
|
|
+ *
|
|
+ * Calling this method causes any existing buffer strategy to be
|
|
+ * destroyed.
|
|
+ *
|
|
+ * @param numBuffers the number of buffers in this strategy
|
|
+ * @param caps the requested buffering capabilities
|
|
+ *
|
|
+ * @throws AWTException if the requested capabilities are not
|
|
+ * supported
|
|
+ * @throws IllegalArgumentException if requested number of buffers
|
|
+ * is less than one or if caps is null
|
|
+ *
|
|
+ * @since 1.4
|
|
+ */
|
|
+ public void createBufferStrategy(int numBuffers,
|
|
+ BufferCapabilities caps)
|
|
+ {
|
|
+ if (numBuffers < 1)
|
|
+ throw new IllegalArgumentException("Window.createBufferStrategy: number"
|
|
+ + " of buffers is less than one");
|
|
+
|
|
+ if (caps == null)
|
|
+ throw new IllegalArgumentException("Window.createBufferStrategy:"
|
|
+ + " capabilities object is null");
|
|
+
|
|
+ // a flipping strategy was requested
|
|
+ if (caps.isPageFlipping())
|
|
+ {
|
|
+ try
|
|
+ {
|
|
+ bufferStrategy = new WindowFlipBufferStrategy(numBuffers);
|
|
+ }
|
|
+ catch (AWTException e)
|
|
+ {
|
|
+ }
|
|
+ }
|
|
+ else
|
|
+ bufferStrategy = new WindowBltBufferStrategy(numBuffers, true);
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * Returns the buffer strategy used by the window.
|
|
+ *
|
|
+ * @return the buffer strategy.
|
|
+ * @since 1.4
|
|
+ */
|
|
+ public BufferStrategy getBufferStrategy()
|
|
+ {
|
|
+ return bufferStrategy;
|
|
+ }
|
|
+
|
|
+ /**
|
|
* @since 1.2
|
|
*
|
|
* @deprecated
|
|
@@ -913,44 +1093,6 @@
|
|
this.focusableWindowState = focusableWindowState;
|
|
}
|
|
|
|
- // 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();
|
|
- boolean resized = width != w || height != h;
|
|
- boolean moved = this.x != x || this.y != y;
|
|
- this.x = x;
|
|
- this.y = y;
|
|
- width = w;
|
|
- height = h;
|
|
- if (resized && isShowing ())
|
|
- {
|
|
- ComponentEvent ce =
|
|
- new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED);
|
|
- getToolkit().getSystemEventQueue().postEvent(ce);
|
|
- }
|
|
- if (moved && isShowing ())
|
|
- {
|
|
- ComponentEvent ce =
|
|
- new ComponentEvent(this, ComponentEvent.COMPONENT_MOVED);
|
|
- getToolkit().getSystemEventQueue().postEvent(ce);
|
|
- }
|
|
- }
|
|
-
|
|
/**
|
|
* Generate a unique name for this window.
|
|
*
|