Mercurial > hg > release > icedtea6-1.10
changeset 2525:e296d9a4e90b
merge
| author | Denis Lila <dlila@redhat.com> |
|---|---|
| date | Wed, 15 Jun 2011 13:46:13 -0400 |
| parents | 8adcdb76aa7c (current diff) 5b3c3dc896d9 (diff) |
| children | 63ba95f1fccc |
| files | ChangeLog Makefile.am NEWS |
| diffstat | 7 files changed, 1768 insertions(+), 13 deletions(-) [+] |
line wrap: on
line diff
--- a/ChangeLog Tue Jun 14 10:09:27 2011 -0400 +++ b/ChangeLog Wed Jun 15 13:46:13 2011 -0400 @@ -1,3 +1,18 @@ +2011-06-15 Denis Lila <dlila@redhat.com> + + * Makefile.am: Apply patches. + * NEWS: Update with backports. + * patches/openjdk/6578583-modality-broken-vista.patch: + * patches/openjdk/6610244-modal-fatal-error-windows.patch: + * patches/openjdk/6769607-modal-hangs.patch: + New patches. The last fixes PR677. The other two are + necessary for the last to fully apply. + * patches/openjdk/6693253-security_warning.patch: + Replsace the awt_Dialog.cpp hunk with the corresponding hunk + from the OpenJDK7 changeset of which this patch is a backport. + Without this change, this patch doesn't apply unless the + previous 3 are removed. + 2011-06-14 Denis Lila <dlila@redhat.com> * Makefile.am: Add patch.
--- a/Makefile.am Tue Jun 14 10:09:27 2011 -0400 +++ b/Makefile.am Wed Jun 15 13:46:13 2011 -0400 @@ -203,6 +203,8 @@ ICEDTEA_PATCHES = \ $(SECURITY_PATCHES) \ + patches/openjdk/6578583-modality-broken-vista.patch \ + patches/openjdk/6610244-modal-fatal-error-windows.patch \ patches/stdc-limit-macros.patch \ patches/openjdk/4993545-nativeinlightfixer.patch \ patches/openjdk/6637796-set_bounds.patch \ @@ -214,6 +216,7 @@ patches/openjdk/6797195-hw_lw_mixing.patch \ patches/openjdk/6725214-direct3d-01.patch \ patches/openjdk/6633275-shaped_translucent_windows.patch \ + patches/openjdk/6769607-modal-hangs.patch \ patches/openjdk/6791612-opengl-jni-fix.patch \ patches/openjdk/6755274-glgetstring-crash.patch \ patches/openjdk/6984543-onscreen_rendering_resize_test.patch \
--- a/NEWS Tue Jun 14 10:09:27 2011 -0400 +++ b/NEWS Wed Jun 15 13:46:13 2011 -0400 @@ -13,6 +13,9 @@ * Backports: - S7037283, RH712211: Null Pointer Exception in SwingUtilities2. + - S6769607, PR677: Modal frame hangs for a while. + - S6578583: Modality is broken in windows vista home premium from jdk1.7 b02 onwards. + - S6610244: modal dialog closes with fatal error if -Xcheck:jni is set New in release 1.10.2 (2011-06-07):
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/6578583-modality-broken-vista.patch Wed Jun 15 13:46:13 2011 -0400 @@ -0,0 +1,1446 @@ +# HG changeset patch +# User dcherepanov +# Date 1205521233 -10800 +# Node ID 15ba7093f8e64e1facdfc48b8929edc6a4fbb0d3 +# Parent 92e3f57c933b45c678abcbccaa47de059dfe926a +6578583: Regression: Modality is broken in windows vista home premium from jdk1.7 b02 onwards. +Summary: WS_DISABLED style should be used to fix some modality bugs +Reviewed-by: art, son + +diff -r 92e3f57c933b -r 15ba7093f8e6 src/windows/native/sun/windows/awt_Component.cpp +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Component.cpp Fri Mar 14 20:40:09 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Component.cpp Fri Mar 14 22:00:33 2008 +0300 +@@ -5425,7 +5425,13 @@ + void AwtComponent::Enable(BOOL bEnable) + { + sm_suppressFocusAndActivation = TRUE; ++ ++ if (bEnable && IsTopLevel()) { ++ // we should not enable blocked toplevels ++ bEnable = !::IsWindow(AwtWindow::GetModalBlocker(GetHWnd())); ++ } + ::EnableWindow(GetHWnd(), bEnable); ++ + sm_suppressFocusAndActivation = FALSE; + CriticalSection::Lock l(GetLock()); + VerifyState(); +diff -r 92e3f57c933b -r 15ba7093f8e6 src/windows/native/sun/windows/awt_Dialog.cpp +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Dialog.cpp Fri Mar 14 20:40:09 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Dialog.cpp Fri Mar 14 22:00:33 2008 +0300 +@@ -273,6 +273,10 @@ + { + HWND blocker = AwtWindow::GetModalBlocker(AwtComponent::GetTopLevelParentForWindow(hWnd)); + HWND topMostBlocker = blocker; ++ HWND prevForegroundWindow = ::GetForegroundWindow(); ++ if (::IsWindow(blocker)) { ++ ::BringWindowToTop(hWnd); ++ } + while (::IsWindow(blocker)) { + topMostBlocker = blocker; + ::BringWindowToTop(blocker); +@@ -282,7 +286,7 @@ + // no beep/flash if the mouse was clicked in the taskbar menu + // or the dialog is currently inactive + if ((::WindowFromPoint(mhs->pt) == hWnd) && +- (::GetForegroundWindow() == topMostBlocker)) ++ (prevForegroundWindow == topMostBlocker)) + { + ::MessageBeep(MB_OK); + // some heuristics: 3 times x 64 milliseconds +@@ -292,6 +296,7 @@ + ::BringWindowToTop(topMostBlocker); + ::SetForegroundWindow(topMostBlocker); + } ++ return 1; + } + } + } +diff -r 92e3f57c933b -r 15ba7093f8e6 src/windows/native/sun/windows/awt_Window.cpp +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Window.cpp Fri Mar 14 20:40:09 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Window.cpp Fri Mar 14 22:00:33 2008 +0300 +@@ -180,7 +180,6 @@ + } + + ::RemoveProp(GetHWnd(), ModalBlockerProp); +- ::RemoveProp(GetHWnd(), ModalSaveWSEXProp); + + if (m_grabbedWindow == this) { + Ungrab(); +@@ -1455,20 +1454,17 @@ + if (!::IsWindow(window)) { + return; + } +- DWORD exStyle = ::GetWindowLong(window, GWL_EXSTYLE); ++ + if (::IsWindow(blocker)) { +- // save WS_EX_NOACTIVATE and WS_EX_APPWINDOW styles +- DWORD saveStyle = exStyle & (AWT_WS_EX_NOACTIVATE | WS_EX_APPWINDOW); +- ::SetProp(window, ModalSaveWSEXProp, reinterpret_cast<HANDLE>(saveStyle)); +- ::SetWindowLong(window, GWL_EXSTYLE, (exStyle | AWT_WS_EX_NOACTIVATE) & ~WS_EX_APPWINDOW); + ::SetProp(window, ModalBlockerProp, reinterpret_cast<HANDLE>(blocker)); ++ ::EnableWindow(window, FALSE); + } else { +- // restore WS_EX_NOACTIVATE and WS_EX_APPWINDOW styles +- DWORD saveStyle = reinterpret_cast<DWORD>(::GetProp(window, ModalSaveWSEXProp)); +- ::SetWindowLong(window, GWL_EXSTYLE, +- (exStyle & ~(AWT_WS_EX_NOACTIVATE | WS_EX_APPWINDOW)) | saveStyle); +- ::RemoveProp(window, ModalSaveWSEXProp); + ::RemoveProp(window, ModalBlockerProp); ++ AwtComponent *comp = AwtComponent::GetComponent(window); ++ // we don't expect to be called with non-java HWNDs ++ DASSERT(comp && comp->IsTopLevel()); ++ // we should not unblock disabled toplevels ++ ::EnableWindow(window, comp->isEnabled()); + } + } + +diff -r 92e3f57c933b -r 15ba7093f8e6 src/windows/native/sun/windows/awt_Window.h +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Window.h Fri Mar 14 20:40:09 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Window.h Fri Mar 14 22:00:33 2008 +0300 +@@ -33,7 +33,6 @@ + + // property name tagging windows disabled by modality + static LPCTSTR ModalBlockerProp = TEXT("SunAwtModalBlockerProp"); +-static LPCTSTR ModalSaveWSEXProp = TEXT("SunAwtModalSaveWSEXProp"); + static LPCTSTR ModalDialogPeerProp = TEXT("SunAwtModalDialogPeerProp"); + + #ifndef WH_MOUSE_LL +diff -r 92e3f57c933b -r 15ba7093f8e6 test/java/awt/Modal/WsDisabledStyle/CloseBlocker/CloseBlocker.java +--- /dev/null Thu Jan 01 00:00:00 1970 +0000 ++++ openjdk/jdk/test/java/awt/Modal/WsDisabledStyle/CloseBlocker/CloseBlocker.java Fri Mar 14 22:00:33 2008 +0300 +@@ -0,0 +1,466 @@ ++/* ++ * Copyright 2007 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code 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 ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ @test %I% %E% ++ @bug 4080029 ++ @summary Modal Dialog block input to all frame windows not just its parent. ++ @author dmitry.cherepanov: area=awt.modal ++ @run main/manual CloseBlocker ++*/ ++ ++/** ++ * ManualMainTest.java ++ * ++ * summary: The test opens and closes blocker dialog, the test verifies ++ * that active window is correct when the dialog is closed. ++ */ ++ ++import java.awt.*; ++import java.awt.event.*; ++ ++public class CloseBlocker ++{ ++ ++ private static void init() ++ { ++ //*** Create instructions for the user here *** ++ ++ String[] instructions = ++ { ++ " the test will be run 6 times, to start next test just close all ", ++ " windows of previous; the instructions are the same for all tests: ", ++ " 1) there are two frames (one the frames has 'show modal' button), ", ++ " 2) press the button to show a dialog, ", ++ " 3) close the dialog (an alternative scenario - activate another", ++ " native window before closing the dialog), ", ++ " 4) the frame with button should become next active window, ", ++ " if it's true, then the test passed, otherwise, it failed. ", ++ " Press 'pass' button only after all of the 6 tests are completed, ", ++ " the number of the currently executed test is displayed on the ", ++ " output window. " ++ }; ++ Sysout.createDialog( ); ++ Sysout.printInstructions( instructions ); ++ ++ test(true, true, false); ++ test(true, true, true); ++ test(false, true, false); // 3rd parameter has no affect for ownerless ++ ++ test(true, false, false); ++ test(true, false, true); ++ test(false, false, false); // 3rd parameter has no affect for ownerless ++ ++ }//End init() ++ ++ private static final Object obj = new Object(); ++ private static int counter = 0; ++ ++ /* ++ * The ownerless parameter indicates whether the blocker dialog ++ * has owner. The usual parameter indicates whether the blocker ++ * dialog is a Java dialog (non-native dialog like file dialog). ++ */ ++ private static void test(final boolean ownerless, final boolean usual, final boolean initiallyOwnerIsActive) { ++ ++ Sysout.print(" * test #" + (++counter) + " is running ... "); ++ ++ final Frame active = new Frame(); ++ final Frame nonactive = new Frame(); ++ Button button = new Button("show modal"); ++ button.addActionListener(new ActionListener() { ++ public void actionPerformed(ActionEvent ae) { ++ Dialog dialog = null; ++ Frame parent = ownerless ? null : (initiallyOwnerIsActive? active : nonactive); ++ if (usual) { ++ dialog = new Dialog(parent, "Sample", true); ++ } else { ++ dialog = new FileDialog(parent, "Sample", FileDialog.LOAD); ++ } ++ dialog.addWindowListener(new WindowAdapter(){ ++ public void windowClosing(WindowEvent e){ ++ e.getWindow().dispose(); ++ } ++ }); ++ dialog.setBounds(200, 200, 200, 200); ++ dialog.setVisible(true); ++ } ++ }); ++ ++ active.add(button); ++ active.setBounds(200, 400, 200, 200); ++ WindowAdapter adapter = new WindowAdapter(){ ++ public void windowClosing(WindowEvent e){ ++ active.dispose(); ++ nonactive.dispose(); ++ synchronized(obj) { ++ obj.notify(); ++ } ++ } ++ }; ++ active.addWindowListener(adapter); ++ active.setVisible(true); ++ ++ nonactive.setBounds(400, 400, 200, 200); ++ nonactive.addWindowListener(adapter); ++ nonactive.setVisible(true); ++ ++ synchronized(obj) { ++ try{ ++ obj.wait(); ++ } catch(Exception e) { ++ throw new RuntimeException(e); ++ } ++ } ++ ++ Sysout.println(" completed. "); ++ ++ } ++ ++ /***************************************************** ++ * Standard Test Machinery Section ++ * DO NOT modify anything in this section -- it's a ++ * standard chunk of code which has all of the ++ * synchronisation necessary for the test harness. ++ * By keeping it the same in all tests, it is easier ++ * to read and understand someone else's test, as ++ * well as insuring that all tests behave correctly ++ * with the test harness. ++ * There is a section following this for test-defined ++ * classes ++ ******************************************************/ ++ private static boolean theTestPassed = false; ++ private static boolean testGeneratedInterrupt = false; ++ private static String failureMessage = ""; ++ ++ private static Thread mainThread = null; ++ ++ private static int sleepTime = 300000; ++ ++ public static void main( String args[] ) throws InterruptedException ++ { ++ mainThread = Thread.currentThread(); ++ try ++ { ++ init(); ++ } ++ catch( TestPassedException e ) ++ { ++ //The test passed, so just return from main and harness will ++ // interepret this return as a pass ++ return; ++ } ++ //At this point, neither test passed nor test failed has been ++ // called -- either would have thrown an exception and ended the ++ // test, so we know we have multiple threads. ++ ++ //Test involves other threads, so sleep and wait for them to ++ // called pass() or fail() ++ try ++ { ++ Thread.sleep( sleepTime ); ++ //Timed out, so fail the test ++ throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" ); ++ } ++ catch (InterruptedException e) ++ { ++ if( ! testGeneratedInterrupt ) throw e; ++ ++ //reset flag in case hit this code more than once for some reason (just safety) ++ testGeneratedInterrupt = false; ++ if ( theTestPassed == false ) ++ { ++ throw new RuntimeException( failureMessage ); ++ } ++ } ++ ++ }//main ++ ++ public static synchronized void setTimeoutTo( int seconds ) ++ { ++ sleepTime = seconds * 1000; ++ } ++ ++ public static synchronized void pass() ++ { ++ Sysout.println( "The test passed." ); ++ Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); ++ //first check if this is executing in main thread ++ if ( mainThread == Thread.currentThread() ) ++ { ++ //Still in the main thread, so set the flag just for kicks, ++ // and throw a test passed exception which will be caught ++ // and end the test. ++ theTestPassed = true; ++ throw new TestPassedException(); ++ } ++ //pass was called from a different thread, so set the flag and interrupt ++ // the main thead. ++ theTestPassed = true; ++ testGeneratedInterrupt = true; ++ mainThread.interrupt(); ++ }//pass() ++ ++ public static synchronized void fail() ++ { ++ //test writer didn't specify why test failed, so give generic ++ fail( "it just plain failed! :-)" ); ++ } ++ ++ public static synchronized void fail( String whyFailed ) ++ { ++ Sysout.println( "The test failed: " + whyFailed ); ++ Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); ++ //check if this called from main thread ++ if ( mainThread == Thread.currentThread() ) ++ { ++ //If main thread, fail now 'cause not sleeping ++ throw new RuntimeException( whyFailed ); ++ } ++ theTestPassed = false; ++ testGeneratedInterrupt = true; ++ failureMessage = whyFailed; ++ mainThread.interrupt(); ++ }//fail() ++ ++}// class ManualMainTest ++ ++//This exception is used to exit from any level of call nesting ++// when it's determined that the test has passed, and immediately ++// end the test. ++class TestPassedException extends RuntimeException ++{ ++} ++ ++//*********** End Standard Test Machinery Section ********** ++ ++ ++//************ Begin classes defined for the test **************** ++ ++// make listeners in a class defined here, and instantiate them in init() ++ ++/* Example of a class which may be written as part of a test ++class NewClass implements anInterface ++ { ++ static int newVar = 0; ++ ++ public void eventDispatched(AWTEvent e) ++ { ++ //Counting events to see if we get enough ++ eventCount++; ++ ++ if( eventCount == 20 ) ++ { ++ //got enough events, so pass ++ ++ ManualMainTest.pass(); ++ } ++ else if( tries == 20 ) ++ { ++ //tried too many times without getting enough events so fail ++ ++ ManualMainTest.fail(); ++ } ++ ++ }// eventDispatched() ++ ++ }// NewClass class ++ ++*/ ++ ++ ++//************** End classes defined for the test ******************* ++ ++ ++ ++ ++/**************************************************** ++ Standard Test Machinery ++ DO NOT modify anything below -- it's a standard ++ chunk of code whose purpose is to make user ++ interaction uniform, and thereby make it simpler ++ to read and understand someone else's test. ++ ****************************************************/ ++ ++/** ++ This is part of the standard test machinery. ++ It creates a dialog (with the instructions), and is the interface ++ for sending text messages to the user. ++ To print the instructions, send an array of strings to Sysout.createDialog ++ WithInstructions method. Put one line of instructions per array entry. ++ To display a message for the tester to see, simply call Sysout.println ++ with the string to be displayed. ++ This mimics System.out.println but works within the test harness as well ++ as standalone. ++ */ ++ ++class Sysout ++{ ++ private static TestDialog dialog; ++ ++ public static void createDialogWithInstructions( String[] instructions ) ++ { ++ dialog = new TestDialog( new Frame(), "Instructions" ); ++ dialog.printInstructions( instructions ); ++ dialog.setVisible(true); ++ println( "Any messages for the tester will display here." ); ++ } ++ ++ public static void createDialog( ) ++ { ++ dialog = new TestDialog( new Frame(), "Instructions" ); ++ String[] defInstr = { "Instructions will appear here. ", "" } ; ++ dialog.printInstructions( defInstr ); ++ dialog.setVisible(true); ++ println( "Any messages for the tester will display here." ); ++ } ++ ++ ++ public static void printInstructions( String[] instructions ) ++ { ++ dialog.printInstructions( instructions ); ++ } ++ ++ ++ public static void println( String messageIn ) ++ { ++ dialog.displayMessage( messageIn, true ); ++ } ++ ++ public static void print( String messageIn ) ++ { ++ dialog.displayMessage( messageIn, false ); ++ } ++ ++}// Sysout class ++ ++/** ++ This is part of the standard test machinery. It provides a place for the ++ test instructions to be displayed, and a place for interactive messages ++ to the user to be displayed. ++ To have the test instructions displayed, see Sysout. ++ To have a message to the user be displayed, see Sysout. ++ Do not call anything in this dialog directly. ++ */ ++class TestDialog extends Dialog implements ActionListener ++{ ++ ++ TextArea instructionsText; ++ TextArea messageText; ++ int maxStringLength = 80; ++ Panel buttonP = new Panel(); ++ Button passB = new Button( "pass" ); ++ Button failB = new Button( "fail" ); ++ ++ //DO NOT call this directly, go through Sysout ++ public TestDialog( Frame frame, String name ) ++ { ++ super( frame, name ); ++ int scrollBoth = TextArea.SCROLLBARS_BOTH; ++ instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth ); ++ add( "North", instructionsText ); ++ ++ messageText = new TextArea( "", 5, maxStringLength, scrollBoth ); ++ add("Center", messageText); ++ ++ passB = new Button( "pass" ); ++ passB.setActionCommand( "pass" ); ++ passB.addActionListener( this ); ++ buttonP.add( "East", passB ); ++ ++ failB = new Button( "fail" ); ++ failB.setActionCommand( "fail" ); ++ failB.addActionListener( this ); ++ buttonP.add( "West", failB ); ++ ++ add( "South", buttonP ); ++ pack(); ++ ++ setVisible(true); ++ }// TestDialog() ++ ++ //DO NOT call this directly, go through Sysout ++ public void printInstructions( String[] instructions ) ++ { ++ //Clear out any current instructions ++ instructionsText.setText( "" ); ++ ++ //Go down array of instruction strings ++ ++ String printStr, remainingStr; ++ for( int i=0; i < instructions.length; i++ ) ++ { ++ //chop up each into pieces maxSringLength long ++ remainingStr = instructions[ i ]; ++ while( remainingStr.length() > 0 ) ++ { ++ //if longer than max then chop off first max chars to print ++ if( remainingStr.length() >= maxStringLength ) ++ { ++ //Try to chop on a word boundary ++ int posOfSpace = remainingStr. ++ lastIndexOf( ' ', maxStringLength - 1 ); ++ ++ if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1; ++ ++ printStr = remainingStr.substring( 0, posOfSpace + 1 ); ++ remainingStr = remainingStr.substring( posOfSpace + 1 ); ++ } ++ //else just print ++ else ++ { ++ printStr = remainingStr; ++ remainingStr = ""; ++ } ++ ++ instructionsText.append( printStr + "\n" ); ++ ++ }// while ++ ++ }// for ++ ++ }//printInstructions() ++ ++ //DO NOT call this directly, go through Sysout ++ public void displayMessage( String messageIn, boolean nextLine ) ++ { ++ messageText.append( messageIn + (nextLine? "\n" : "") ); ++ System.out.println(messageIn); ++ } ++ ++ //catch presses of the passed and failed buttons. ++ //simply call the standard pass() or fail() static methods of ++ //ManualMainTest ++ public void actionPerformed( ActionEvent e ) ++ { ++ if( e.getActionCommand() == "pass" ) ++ { ++ CloseBlocker.pass(); ++ } ++ else ++ { ++ CloseBlocker.fail(); ++ } ++ } ++ ++}// TestDialog class +diff -r 92e3f57c933b -r 15ba7093f8e6 test/java/awt/Modal/WsDisabledStyle/OverBlocker/OverBlocker.java +--- /dev/null Thu Jan 01 00:00:00 1970 +0000 ++++ openjdk/jdk/test/java/awt/Modal/WsDisabledStyle/OverBlocker/OverBlocker.java Fri Mar 14 22:00:33 2008 +0300 +@@ -0,0 +1,456 @@ ++/* ++ * Copyright 2007 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code 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 ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ @test %I% %E% ++ @bug 4080029 ++ @summary Modal Dialog block input to all frame windows not just its parent. ++ @author dmitry.cherepanov: area=awt.modal ++ @run main/manual OverBlocker ++*/ ++ ++/** ++ * OverBlocker.java ++ * ++ * summary: The test verifies that if user tries to activate the blocked dialog ++ * then the blocker dialog appears over the other windows ++ */ ++ ++import java.awt.*; ++import java.awt.event.*; ++ ++public class OverBlocker ++{ ++ ++ private static void init() ++ { ++ //*** Create instructions for the user here *** ++ ++ String[] instructions = ++ { ++ " the test will be run 4 times, to start next test just close all ", ++ " windows of previous; the instructions are the same for all tests: ", ++ " 1) there is a frame with 'show modal' button, ", ++ " 2) press the button to show a dialog, ", ++ " 3) activate any non-Java application, move the app over the dialog, ", ++ " 4) click on the frame by mouse, ", ++ " 5) make sure that the dialog comes up from the application and ", ++ " now the dialog overlaps the app as well as the frame, ", ++ " if it's true, then the test passed, otherwise, it failed. ", ++ " Press 'pass' button only after all of the 4 tests are completed, ", ++ " the number of the currently executed test is displayed on the ", ++ " output window. " ++ }; ++ Sysout.createDialog( ); ++ Sysout.printInstructions( instructions ); ++ ++ test(false, true); ++ test(true, true); ++ test(true, false); ++ test(false, false); ++ ++ }//End init() ++ ++ private static final Object obj = new Object(); ++ private static int counter = 0; ++ ++ /* ++ * The ownerless parameter indicates whether the blocker dialog ++ * has owner. The usual parameter indicates whether the blocker ++ * dialog is a Java dialog (non-native dialog like file dialog). ++ */ ++ private static void test(final boolean ownerless, final boolean usual) { ++ ++ Sysout.print(" * test #" + (++counter) + " is running ... "); ++ ++ final Frame frame = new Frame(); ++ Button button = new Button("show modal"); ++ button.addActionListener(new ActionListener() { ++ public void actionPerformed(ActionEvent ae) { ++ Dialog dialog = null; ++ Frame parent = ownerless ? null : frame; ++ if (usual) { ++ dialog = new Dialog(parent, "Sample", true); ++ } else { ++ dialog = new FileDialog(parent, "Sample", FileDialog.LOAD); ++ } ++ dialog.addWindowListener(new WindowAdapter(){ ++ public void windowClosing(WindowEvent e){ ++ e.getWindow().dispose(); ++ } ++ }); ++ dialog.setBounds(200, 200, 200, 200); ++ dialog.setVisible(true); ++ } ++ }); ++ frame.add(button); ++ frame.setBounds(400, 400, 200, 200); ++ frame.addWindowListener(new WindowAdapter(){ ++ public void windowClosing(WindowEvent e){ ++ e.getWindow().dispose(); ++ synchronized(obj) { ++ obj.notify(); ++ } ++ } ++ }); ++ frame.setVisible(true); ++ ++ synchronized(obj) { ++ try{ ++ obj.wait(); ++ } catch(Exception e) { ++ throw new RuntimeException(e); ++ } ++ } ++ ++ Sysout.println(" completed. "); ++ ++ } ++ ++ /***************************************************** ++ * Standard Test Machinery Section ++ * DO NOT modify anything in this section -- it's a ++ * standard chunk of code which has all of the ++ * synchronisation necessary for the test harness. ++ * By keeping it the same in all tests, it is easier ++ * to read and understand someone else's test, as ++ * well as insuring that all tests behave correctly ++ * with the test harness. ++ * There is a section following this for test-defined ++ * classes ++ ******************************************************/ ++ private static boolean theTestPassed = false; ++ private static boolean testGeneratedInterrupt = false; ++ private static String failureMessage = ""; ++ ++ private static Thread mainThread = null; ++ ++ private static int sleepTime = 300000; ++ ++ public static void main( String args[] ) throws InterruptedException ++ { ++ mainThread = Thread.currentThread(); ++ try ++ { ++ init(); ++ } ++ catch( TestPassedException e ) ++ { ++ //The test passed, so just return from main and harness will ++ // interepret this return as a pass ++ return; ++ } ++ //At this point, neither test passed nor test failed has been ++ // called -- either would have thrown an exception and ended the ++ // test, so we know we have multiple threads. ++ ++ //Test involves other threads, so sleep and wait for them to ++ // called pass() or fail() ++ try ++ { ++ Thread.sleep( sleepTime ); ++ //Timed out, so fail the test ++ throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" ); ++ } ++ catch (InterruptedException e) ++ { ++ if( ! testGeneratedInterrupt ) throw e; ++ ++ //reset flag in case hit this code more than once for some reason (just safety) ++ testGeneratedInterrupt = false; ++ if ( theTestPassed == false ) ++ { ++ throw new RuntimeException( failureMessage ); ++ } ++ } ++ ++ }//main ++ ++ public static synchronized void setTimeoutTo( int seconds ) ++ { ++ sleepTime = seconds * 1000; ++ } ++ ++ public static synchronized void pass() ++ { ++ Sysout.println( "The test passed." ); ++ Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); ++ //first check if this is executing in main thread ++ if ( mainThread == Thread.currentThread() ) ++ { ++ //Still in the main thread, so set the flag just for kicks, ++ // and throw a test passed exception which will be caught ++ // and end the test. ++ theTestPassed = true; ++ throw new TestPassedException(); ++ } ++ //pass was called from a different thread, so set the flag and interrupt ++ // the main thead. ++ theTestPassed = true; ++ testGeneratedInterrupt = true; ++ mainThread.interrupt(); ++ }//pass() ++ ++ public static synchronized void fail() ++ { ++ //test writer didn't specify why test failed, so give generic ++ fail( "it just plain failed! :-)" ); ++ } ++ ++ public static synchronized void fail( String whyFailed ) ++ { ++ Sysout.println( "The test failed: " + whyFailed ); ++ Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); ++ //check if this called from main thread ++ if ( mainThread == Thread.currentThread() ) ++ { ++ //If main thread, fail now 'cause not sleeping ++ throw new RuntimeException( whyFailed ); ++ } ++ theTestPassed = false; ++ testGeneratedInterrupt = true; ++ failureMessage = whyFailed; ++ mainThread.interrupt(); ++ }//fail() ++ ++}// class ManualMainTest ++ ++//This exception is used to exit from any level of call nesting ++// when it's determined that the test has passed, and immediately ++// end the test. ++class TestPassedException extends RuntimeException ++{ ++} ++ ++//*********** End Standard Test Machinery Section ********** ++ ++ ++//************ Begin classes defined for the test **************** ++ ++// make listeners in a class defined here, and instantiate them in init() ++ ++/* Example of a class which may be written as part of a test ++class NewClass implements anInterface ++ { ++ static int newVar = 0; ++ ++ public void eventDispatched(AWTEvent e) ++ { ++ //Counting events to see if we get enough ++ eventCount++; ++ ++ if( eventCount == 20 ) ++ { ++ //got enough events, so pass ++ ++ ManualMainTest.pass(); ++ } ++ else if( tries == 20 ) ++ { ++ //tried too many times without getting enough events so fail ++ ++ ManualMainTest.fail(); ++ } ++ ++ }// eventDispatched() ++ ++ }// NewClass class ++ ++*/ ++ ++ ++//************** End classes defined for the test ******************* ++ ++ ++ ++ ++/**************************************************** ++ Standard Test Machinery ++ DO NOT modify anything below -- it's a standard ++ chunk of code whose purpose is to make user ++ interaction uniform, and thereby make it simpler ++ to read and understand someone else's test. ++ ****************************************************/ ++ ++/** ++ This is part of the standard test machinery. ++ It creates a dialog (with the instructions), and is the interface ++ for sending text messages to the user. ++ To print the instructions, send an array of strings to Sysout.createDialog ++ WithInstructions method. Put one line of instructions per array entry. ++ To display a message for the tester to see, simply call Sysout.println ++ with the string to be displayed. ++ This mimics System.out.println but works within the test harness as well ++ as standalone. ++ */ ++ ++class Sysout ++{ ++ private static TestDialog dialog; ++ ++ public static void createDialogWithInstructions( String[] instructions ) ++ { ++ dialog = new TestDialog( new Frame(), "Instructions" ); ++ dialog.printInstructions( instructions ); ++ dialog.setVisible(true); ++ println( "Any messages for the tester will display here." ); ++ } ++ ++ public static void createDialog( ) ++ { ++ dialog = new TestDialog( new Frame(), "Instructions" ); ++ String[] defInstr = { "Instructions will appear here. ", "" } ; ++ dialog.printInstructions( defInstr ); ++ dialog.setVisible(true); ++ println( "Any messages for the tester will display here." ); ++ } ++ ++ ++ public static void printInstructions( String[] instructions ) ++ { ++ dialog.printInstructions( instructions ); ++ } ++ ++ ++ public static void println( String messageIn ) ++ { ++ dialog.displayMessage( messageIn, true ); ++ } ++ ++ public static void print( String messageIn ) ++ { ++ dialog.displayMessage( messageIn, false ); ++ } ++ ++}// Sysout class ++ ++/** ++ This is part of the standard test machinery. It provides a place for the ++ test instructions to be displayed, and a place for interactive messages ++ to the user to be displayed. ++ To have the test instructions displayed, see Sysout. ++ To have a message to the user be displayed, see Sysout. ++ Do not call anything in this dialog directly. ++ */ ++class TestDialog extends Dialog implements ActionListener ++{ ++ ++ TextArea instructionsText; ++ TextArea messageText; ++ int maxStringLength = 80; ++ Panel buttonP = new Panel(); ++ Button passB = new Button( "pass" ); ++ Button failB = new Button( "fail" ); ++ ++ //DO NOT call this directly, go through Sysout ++ public TestDialog( Frame frame, String name ) ++ { ++ super( frame, name ); ++ int scrollBoth = TextArea.SCROLLBARS_BOTH; ++ instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth ); ++ add( "North", instructionsText ); ++ ++ messageText = new TextArea( "", 5, maxStringLength, scrollBoth ); ++ add("Center", messageText); ++ ++ passB = new Button( "pass" ); ++ passB.setActionCommand( "pass" ); ++ passB.addActionListener( this ); ++ buttonP.add( "East", passB ); ++ ++ failB = new Button( "fail" ); ++ failB.setActionCommand( "fail" ); ++ failB.addActionListener( this ); ++ buttonP.add( "West", failB ); ++ ++ add( "South", buttonP ); ++ pack(); ++ ++ setVisible(true); ++ }// TestDialog() ++ ++ //DO NOT call this directly, go through Sysout ++ public void printInstructions( String[] instructions ) ++ { ++ //Clear out any current instructions ++ instructionsText.setText( "" ); ++ ++ //Go down array of instruction strings ++ ++ String printStr, remainingStr; ++ for( int i=0; i < instructions.length; i++ ) ++ { ++ //chop up each into pieces maxSringLength long ++ remainingStr = instructions[ i ]; ++ while( remainingStr.length() > 0 ) ++ { ++ //if longer than max then chop off first max chars to print ++ if( remainingStr.length() >= maxStringLength ) ++ { ++ //Try to chop on a word boundary ++ int posOfSpace = remainingStr. ++ lastIndexOf( ' ', maxStringLength - 1 ); ++ ++ if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1; ++ ++ printStr = remainingStr.substring( 0, posOfSpace + 1 ); ++ remainingStr = remainingStr.substring( posOfSpace + 1 ); ++ } ++ //else just print ++ else ++ { ++ printStr = remainingStr; ++ remainingStr = ""; ++ } ++ ++ instructionsText.append( printStr + "\n" ); ++ ++ }// while ++ ++ }// for ++ ++ }//printInstructions() ++ ++ //DO NOT call this directly, go through Sysout ++ public void displayMessage( String messageIn, boolean nextLine ) ++ { ++ messageText.append( messageIn + (nextLine? "\n" : "") ); ++ System.out.println(messageIn); ++ } ++ ++ //catch presses of the passed and failed buttons. ++ //simply call the standard pass() or fail() static methods of ++ //ManualMainTest ++ public void actionPerformed( ActionEvent e ) ++ { ++ if( e.getActionCommand() == "pass" ) ++ { ++ OverBlocker.pass(); ++ } ++ else ++ { ++ OverBlocker.fail(); ++ } ++ } ++ ++}// TestDialog class +diff -r 92e3f57c933b -r 15ba7093f8e6 test/java/awt/Modal/WsDisabledStyle/Winkey/Winkey.java +--- /dev/null Thu Jan 01 00:00:00 1970 +0000 ++++ openjdk/jdk/test/java/awt/Modal/WsDisabledStyle/Winkey/Winkey.java Fri Mar 14 22:00:33 2008 +0300 +@@ -0,0 +1,403 @@ ++/* ++ * Copyright 2007 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code 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 ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ @test %I% %E% ++ @bug 6572263 6571808 ++ @summary PIT:FileDialog minimized to taskbar(through 'Show Desktop')selecting the fileDialog using windowList ++ @author dmitry.cherepanov: area=awt.modal ++ @run main/manual Winkey ++*/ ++ ++/** ++ * Winkey.java ++ * ++ * summary: the test verifies that pressing combination of Windows key ++ * and M key to minimize all windows doesn't break AWT modality ++ */ ++ ++import java.awt.*; ++import java.awt.event.*; ++ ++public class Winkey ++{ ++ ++ private static void init() ++ { ++ //*** Create instructions for the user here *** ++ ++ String[] instructions = ++ { ++ " 1. there is a frame with a 'show modal' button, ", ++ " 2. press the button to show a modal dialog, ", ++ " 3. the modal dialog will be shown over the frame, ", ++ " 4. please verify that all (5.1, 5.2.1, 5.2.2) the following tests pass: ", ++ " ", ++ " 5.1. press combination Windows Key and M key to minimize all windows, ", ++ " 5.2. press combination Windows Key and D key to show desktop, ", ++ " 5.2.1. restore the dialog by choosing this one in the ALT-TAB list, ", ++ " 5.2.2. restore the dialog by mouse click on taskbar (on java or any other item)", ++ " ", ++ " 6. make sure that the dialog and the frame are visible, ", ++ " the bounds of the windows should be the same as before, ", ++ " if it's true, then the test passed; otherwise, it failed. " ++ }; ++ Sysout.createDialog( ); ++ Sysout.printInstructions( instructions ); ++ ++ final Frame frame = new Frame(); ++ Button button = new Button("show modal"); ++ button.addActionListener(new ActionListener() { ++ public void actionPerformed(ActionEvent ae) { ++ FileDialog dialog = new FileDialog((Frame)null, "Sample", FileDialog.LOAD); ++ dialog.setVisible(true); ++ } ++ }); ++ frame.add(button); ++ frame.setBounds(400, 400, 200, 200); ++ frame.setVisible(true); ++ ++ }//End init() ++ ++ /***************************************************** ++ * Standard Test Machinery Section ++ * DO NOT modify anything in this section -- it's a ++ * standard chunk of code which has all of the ++ * synchronisation necessary for the test harness. ++ * By keeping it the same in all tests, it is easier ++ * to read and understand someone else's test, as ++ * well as insuring that all tests behave correctly ++ * with the test harness. ++ * There is a section following this for test-defined ++ * classes ++ ******************************************************/ ++ private static boolean theTestPassed = false; ++ private static boolean testGeneratedInterrupt = false; ++ private static String failureMessage = ""; ++ ++ private static Thread mainThread = null; ++ ++ private static int sleepTime = 300000; ++ ++ public static void main( String args[] ) throws InterruptedException ++ { ++ mainThread = Thread.currentThread(); ++ try ++ { ++ init(); ++ } ++ catch( TestPassedException e ) ++ { ++ //The test passed, so just return from main and harness will ++ // interepret this return as a pass ++ return; ++ } ++ //At this point, neither test passed nor test failed has been ++ // called -- either would have thrown an exception and ended the ++ // test, so we know we have multiple threads. ++ ++ //Test involves other threads, so sleep and wait for them to ++ // called pass() or fail() ++ try ++ { ++ Thread.sleep( sleepTime ); ++ //Timed out, so fail the test ++ throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" ); ++ } ++ catch (InterruptedException e) ++ { ++ if( ! testGeneratedInterrupt ) throw e; ++ ++ //reset flag in case hit this code more than once for some reason (just safety) ++ testGeneratedInterrupt = false; ++ if ( theTestPassed == false ) ++ { ++ throw new RuntimeException( failureMessage ); ++ } ++ } ++ ++ }//main ++ ++ public static synchronized void setTimeoutTo( int seconds ) ++ { ++ sleepTime = seconds * 1000; ++ } ++ ++ public static synchronized void pass() ++ { ++ Sysout.println( "The test passed." ); ++ Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); ++ //first check if this is executing in main thread ++ if ( mainThread == Thread.currentThread() ) ++ { ++ //Still in the main thread, so set the flag just for kicks, ++ // and throw a test passed exception which will be caught ++ // and end the test. ++ theTestPassed = true; ++ throw new TestPassedException(); ++ } ++ //pass was called from a different thread, so set the flag and interrupt ++ // the main thead. ++ theTestPassed = true; ++ testGeneratedInterrupt = true; ++ mainThread.interrupt(); ++ }//pass() ++ ++ public static synchronized void fail() ++ { ++ //test writer didn't specify why test failed, so give generic ++ fail( "it just plain failed! :-)" ); ++ } ++ ++ public static synchronized void fail( String whyFailed ) ++ { ++ Sysout.println( "The test failed: " + whyFailed ); ++ Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); ++ //check if this called from main thread ++ if ( mainThread == Thread.currentThread() ) ++ { ++ //If main thread, fail now 'cause not sleeping ++ throw new RuntimeException( whyFailed ); ++ } ++ theTestPassed = false; ++ testGeneratedInterrupt = true; ++ failureMessage = whyFailed; ++ mainThread.interrupt(); ++ }//fail() ++ ++}// class ManualMainTest ++ ++//This exception is used to exit from any level of call nesting ++// when it's determined that the test has passed, and immediately ++// end the test. ++class TestPassedException extends RuntimeException ++{ ++} ++ ++//*********** End Standard Test Machinery Section ********** ++ ++ ++//************ Begin classes defined for the test **************** ++ ++// make listeners in a class defined here, and instantiate them in init() ++ ++/* Example of a class which may be written as part of a test ++class NewClass implements anInterface ++ { ++ static int newVar = 0; ++ ++ public void eventDispatched(AWTEvent e) ++ { ++ //Counting events to see if we get enough ++ eventCount++; ++ ++ if( eventCount == 20 ) ++ { ++ //got enough events, so pass ++ ++ ManualMainTest.pass(); ++ } ++ else if( tries == 20 ) ++ { ++ //tried too many times without getting enough events so fail ++ ++ ManualMainTest.fail(); ++ } ++ ++ }// eventDispatched() ++ ++ }// NewClass class ++ ++*/ ++ ++ ++//************** End classes defined for the test ******************* ++ ++ ++ ++ ++/**************************************************** ++ Standard Test Machinery ++ DO NOT modify anything below -- it's a standard ++ chunk of code whose purpose is to make user ++ interaction uniform, and thereby make it simpler ++ to read and understand someone else's test. ++ ****************************************************/ ++ ++/** ++ This is part of the standard test machinery. ++ It creates a dialog (with the instructions), and is the interface ++ for sending text messages to the user. ++ To print the instructions, send an array of strings to Sysout.createDialog ++ WithInstructions method. Put one line of instructions per array entry. ++ To display a message for the tester to see, simply call Sysout.println ++ with the string to be displayed. ++ This mimics System.out.println but works within the test harness as well ++ as standalone. ++ */ ++ ++class Sysout ++{ ++ private static TestDialog dialog; ++ ++ public static void createDialogWithInstructions( String[] instructions ) ++ { ++ dialog = new TestDialog( new Frame(), "Instructions" ); ++ dialog.printInstructions( instructions ); ++ dialog.setVisible(true); ++ println( "Any messages for the tester will display here." ); ++ } ++ ++ public static void createDialog( ) ++ { ++ dialog = new TestDialog( new Frame(), "Instructions" ); ++ String[] defInstr = { "Instructions will appear here. ", "" } ; ++ dialog.printInstructions( defInstr ); ++ dialog.setVisible(true); ++ println( "Any messages for the tester will display here." ); ++ } ++ ++ ++ public static void printInstructions( String[] instructions ) ++ { ++ dialog.printInstructions( instructions ); ++ } ++ ++ ++ public static void println( String messageIn ) ++ { ++ dialog.displayMessage( messageIn ); ++ } ++ ++}// Sysout class ++ ++/** ++ This is part of the standard test machinery. It provides a place for the ++ test instructions to be displayed, and a place for interactive messages ++ to the user to be displayed. ++ To have the test instructions displayed, see Sysout. ++ To have a message to the user be displayed, see Sysout. ++ Do not call anything in this dialog directly. ++ */ ++class TestDialog extends Dialog implements ActionListener ++{ ++ ++ TextArea instructionsText; ++ TextArea messageText; ++ int maxStringLength = 80; ++ Panel buttonP = new Panel(); ++ Button passB = new Button( "pass" ); ++ Button failB = new Button( "fail" ); ++ ++ //DO NOT call this directly, go through Sysout ++ public TestDialog( Frame frame, String name ) ++ { ++ super( frame, name ); ++ int scrollBoth = TextArea.SCROLLBARS_BOTH; ++ instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth ); ++ add( "North", instructionsText ); ++ ++ messageText = new TextArea( "", 5, maxStringLength, scrollBoth ); ++ add("Center", messageText); ++ ++ passB = new Button( "pass" ); ++ passB.setActionCommand( "pass" ); ++ passB.addActionListener( this ); ++ buttonP.add( "East", passB ); ++ ++ failB = new Button( "fail" ); ++ failB.setActionCommand( "fail" ); ++ failB.addActionListener( this ); ++ buttonP.add( "West", failB ); ++ ++ add( "South", buttonP ); ++ pack(); ++ ++ setVisible(true); ++ }// TestDialog() ++ ++ //DO NOT call this directly, go through Sysout ++ public void printInstructions( String[] instructions ) ++ { ++ //Clear out any current instructions ++ instructionsText.setText( "" ); ++ ++ //Go down array of instruction strings ++ ++ String printStr, remainingStr; ++ for( int i=0; i < instructions.length; i++ ) ++ { ++ //chop up each into pieces maxSringLength long ++ remainingStr = instructions[ i ]; ++ while( remainingStr.length() > 0 ) ++ { ++ //if longer than max then chop off first max chars to print ++ if( remainingStr.length() >= maxStringLength ) ++ { ++ //Try to chop on a word boundary ++ int posOfSpace = remainingStr. ++ lastIndexOf( ' ', maxStringLength - 1 ); ++ ++ if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1; ++ ++ printStr = remainingStr.substring( 0, posOfSpace + 1 ); ++ remainingStr = remainingStr.substring( posOfSpace + 1 ); ++ } ++ //else just print ++ else ++ { ++ printStr = remainingStr; ++ remainingStr = ""; ++ } ++ ++ instructionsText.append( printStr + "\n" ); ++ ++ }// while ++ ++ }// for ++ ++ }//printInstructions() ++ ++ //DO NOT call this directly, go through Sysout ++ public void displayMessage( String messageIn ) ++ { ++ messageText.append( messageIn + "\n" ); ++ System.out.println(messageIn); ++ } ++ ++ //catch presses of the passed and failed buttons. ++ //simply call the standard pass() or fail() static methods of ++ //ManualMainTest ++ public void actionPerformed( ActionEvent e ) ++ { ++ if( e.getActionCommand() == "pass" ) ++ { ++ Winkey.pass(); ++ } ++ else ++ { ++ Winkey.fail(); ++ } ++ } ++ ++}// TestDialog class +exporting patch: +<fdopen>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/6610244-modal-fatal-error-windows.patch Wed Jun 15 13:46:13 2011 -0400 @@ -0,0 +1,125 @@ +# HG changeset patch +# User dav +# Date 1206447363 -10800 +# Node ID 58c90502785df64cd26e9f2d400429dcfcaa3b91 +# Parent de9e902b1f24bef3ec7248890caa1722983e68f5 +6610244: modal dialog closes with fatal error if -Xcheck:jni is set +Summary: obtain WWindowPeer class every time it is required +Reviewed-by: art + +diff -r de9e902b1f24 -r 58c90502785d src/windows/native/sun/windows/awt_Dialog.cpp +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Dialog.cpp Mon Mar 24 18:24:15 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Dialog.cpp Tue Mar 25 15:16:03 2008 +0300 +@@ -428,8 +428,12 @@ + { + JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); + +- jlongArray windows = (jlongArray)(env->CallStaticObjectMethod(AwtWindow::wwindowPeerCls, +- AwtWindow::getActiveWindowsMID)); ++ jclass wwindowPeerCls = env->FindClass("sun/awt/windows/WWindowPeer"); ++ jmethodID getActiveWindowsMID = env->GetStaticMethodID(wwindowPeerCls, ++ "getActiveWindowHandles", "()[J"); ++ DASSERT(getActiveWindowsMID != NULL); ++ jlongArray windows = (jlongArray)(env->CallStaticObjectMethod(wwindowPeerCls, ++ getActiveWindowsMID)); + if (windows == NULL) { + return; + } +diff -r de9e902b1f24 -r 58c90502785d src/windows/native/sun/windows/awt_Window.cpp +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Window.cpp Mon Mar 24 18:24:15 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Window.cpp Tue Mar 25 15:16:03 2008 +0300 +@@ -122,9 +122,6 @@ + jfieldID AwtWindow::locationByPlatformID; + jfieldID AwtWindow::autoRequestFocusID; + +-jclass AwtWindow::wwindowPeerCls; +-jmethodID AwtWindow::getActiveWindowsMID; +- + jfieldID AwtWindow::sysXID; + jfieldID AwtWindow::sysYID; + jfieldID AwtWindow::sysWID; +diff -r de9e902b1f24 -r 58c90502785d src/windows/native/sun/windows/awt_Window.h +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Window.h Mon Mar 24 18:24:15 2008 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Window.h Tue Mar 25 15:16:03 2008 +0300 +@@ -57,11 +57,6 @@ + static jfieldID screenID; /* screen number passed over from WindowPeer */ + static jfieldID autoRequestFocusID; + +- /* WWindowPeer class */ +- static jclass wwindowPeerCls; +- /* long[] getActiveWindowHandles() method in WWindowPeer */ +- static jmethodID getActiveWindowsMID; +- + // The coordinates at the peer. + static jfieldID sysXID; + static jfieldID sysYID; +diff -r de9e902b1f24 -r 58c90502785d test/java/awt/Dialog/CrashXCheckJni/CrashXCheckJni.java +--- /dev/null Thu Jan 01 00:00:00 1970 +0000 ++++ openjdk/jdk/test/java/awt/Dialog/CrashXCheckJni/CrashXCheckJni.java Tue Mar 25 15:16:03 2008 +0300 +@@ -0,0 +1,64 @@ ++/* ++ * Copyright 2008 Sun Microsystems, Inc. All Rights Reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code 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 ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, ++ * CA 95054 USA or visit www.sun.com if you need additional information or ++ * have any questions. ++ */ ++ ++/* ++ @test ++ @bug 6610244 ++ @library ../../regtesthelpers ++ @build Util Sysout AbstractTest ++ @summary modal dialog closes with fatal error if -Xcheck:jni is set ++ @author Andrei Dmitriev : area=awt.dialog ++ @run main/othervm -Xcheck:jni CrashXCheckJni ++*/ ++ ++import java.awt.*; ++import java.awt.event.*; ++import java.util.Timer; ++import java.util.TimerTask; ++import test.java.awt.regtesthelpers.Util; ++import test.java.awt.regtesthelpers.AbstractTest; ++import test.java.awt.regtesthelpers.Sysout; ++ ++public class CrashXCheckJni { ++ ++ public static void main(String []s) ++ { ++ final Dialog fd = new Dialog(new Frame(), true); ++ Timer t = new Timer(); ++ t.schedule(new TimerTask() { ++ ++ public void run() { ++ System.out.println("RUNNING TASK"); ++ fd.setVisible(false); ++ fd.dispose(); ++ System.out.println("FINISHING TASK"); ++ } ++ }, 3000L); ++ ++ fd.setVisible(true); ++ t.cancel(); ++ Util.waitForIdle(null); ++ ++ AbstractTest.pass(); ++ } ++} +exporting patch: +<fdopen>
--- a/patches/openjdk/6693253-security_warning.patch Tue Jun 14 10:09:27 2011 -0400 +++ b/patches/openjdk/6693253-security_warning.patch Wed Jun 15 13:46:13 2011 -0400 @@ -3280,19 +3280,18 @@ diff -Nru openjdk.orig/jdk/src/windows/native/sun/windows/awt_Dialog.cpp openjdk/jdk/src/windows/native/sun/windows/awt_Dialog.cpp --- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Dialog.cpp 2011-01-20 23:54:44.000000000 +0000 +++ openjdk/jdk/src/windows/native/sun/windows/awt_Dialog.cpp 2011-02-17 15:50:10.732056235 +0000 -@@ -284,9 +284,7 @@ - if ((::WindowFromPoint(mhs->pt) == hWnd) && - (::GetForegroundWindow() == topMostBlocker)) - { -- ::MessageBeep(MB_OK); -- // some heuristics: 3 times x 64 milliseconds -- AwtWindow::FlashWindowEx(topMostBlocker, 3, 64, FLASHW_CAPTION); -+ AnimateModalBlocker(dialog); - } - if (topMostBlocker != AwtToolkit::GetInstance().GetHWnd()) { - ::BringWindowToTop(topMostBlocker); -@@ -299,6 +297,13 @@ - return CallNextHookEx(0, nCode, wParam, lParam); +@@ -310,15 +310,20 @@ + // no beep/flash if the mouse was clicked in the taskbar menu + // or the dialog is currently inactive + if (!isModalHook && !onTaskbar && (dialog == prevFGWindow)) { +- ::MessageBeep(MB_OK); +- // some heuristics: 3 times x 64 milliseconds +- AwtWindow::FlashWindowEx(dialog, 3, 64, FLASHW_CAPTION); ++ AnimateModalBlocker(dialog); + } + ::BringWindowToTop(dialog); + ::SetForegroundWindow(dialog); + } } +void AwtDialog::AnimateModalBlocker(HWND window)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/6769607-modal-hangs.patch Wed Jun 15 13:46:13 2011 -0400 @@ -0,0 +1,164 @@ +# HG changeset patch +# User dcherepanov +# Date 1234870023 -10800 +# Node ID 5453a374c1d5838bf924e27fcd790d4bd9cadb2a +# Parent 03276203c39cd11758db94645f9173e04ae47c3a +6769607: PIT : Modal frame hangs for a while for few seconds in 6u12 b01 pit build +Reviewed-by: art, anthony + +diff -r 03276203c39c -r 5453a374c1d5 src/share/classes/java/awt/Window.java +--- openjdk.orig/jdk/src/share/classes/java/awt/Window.java Tue Feb 17 10:42:12 2009 +0300 ++++ openjdk/jdk/src/share/classes/java/awt/Window.java Tue Feb 17 14:27:03 2009 +0300 +@@ -687,9 +687,9 @@ + } + if (peer == null) { + peer = getToolkit().createWindow(this); +- synchronized (allWindows) { +- allWindows.add(this); +- } ++ } ++ synchronized (allWindows) { ++ allWindows.add(this); + } + super.addNotify(); + } +diff -r 03276203c39c -r 5453a374c1d5 src/windows/native/sun/windows/awt_Dialog.cpp +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Dialog.cpp Tue Feb 17 10:42:12 2009 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Dialog.cpp Tue Feb 17 14:27:03 2009 +0300 +@@ -230,25 +230,8 @@ + if (::IsIconic(hWnd)) { + ::ShowWindow(hWnd, SW_RESTORE); + } +- HWND topMostBlocker = blocker; +- HWND toolkitHWnd = AwtToolkit::GetInstance().GetHWnd(); +- while (::IsWindow(blocker)) { +- topMostBlocker = blocker; +- // fix for 6494032: restore the blocker if it was minimized +- // together with its parent frame; in such cases the check +- // ::IsIconic() for the blocker returns false, so we use +- // ::IsWindowVisible() instead +- if (!::IsWindowVisible(topMostBlocker) && +- (topMostBlocker != toolkitHWnd)) +- { +- ::ShowWindow(topMostBlocker, SW_SHOWNA); +- } +- ::BringWindowToTop(blocker); +- blocker = AwtWindow::GetModalBlocker(blocker); +- } +- if (topMostBlocker != toolkitHWnd) { +- ::SetForegroundWindow(topMostBlocker); +- } ++ PopupAllDialogs(blocker, TRUE, ::GetForegroundWindow(), FALSE); ++ // return 1 to prevent the system from allowing the operation + return 1; + } + return CallNextHookEx(0, code, wParam, lParam); +@@ -271,30 +254,11 @@ + (wParam == WM_NCRBUTTONDOWN)) + { + HWND blocker = AwtWindow::GetModalBlocker(AwtComponent::GetTopLevelParentForWindow(hWnd)); +- HWND topMostBlocker = blocker; +- HWND prevForegroundWindow = ::GetForegroundWindow(); + if (::IsWindow(blocker)) { +- ::BringWindowToTop(hWnd); +- } +- while (::IsWindow(blocker)) { +- topMostBlocker = blocker; +- ::BringWindowToTop(blocker); +- blocker = AwtWindow::GetModalBlocker(blocker); +- } +- if (::IsWindow(topMostBlocker)) { +- // no beep/flash if the mouse was clicked in the taskbar menu +- // or the dialog is currently inactive +- if ((::WindowFromPoint(mhs->pt) == hWnd) && +- (prevForegroundWindow == topMostBlocker)) +- { +- ::MessageBeep(MB_OK); +- // some heuristics: 3 times x 64 milliseconds +- AwtWindow::FlashWindowEx(topMostBlocker, 3, 64, FLASHW_CAPTION); +- } +- if (topMostBlocker != AwtToolkit::GetInstance().GetHWnd()) { +- ::BringWindowToTop(topMostBlocker); +- ::SetForegroundWindow(topMostBlocker); +- } ++ BOOL onTaskbar = !(::WindowFromPoint(mhs->pt) == hWnd); ++ PopupAllDialogs(hWnd, FALSE, ::GetForegroundWindow(), onTaskbar); ++ // return a nonzero value to prevent the system from passing ++ // the message to the target window procedure + return 1; + } + } +@@ -303,6 +267,58 @@ + return CallNextHookEx(0, nCode, wParam, lParam); + } + ++/* ++ * The function goes through the heirarchy of the blocker dialogs and ++ * popups all the dialogs. Note that the function starts from the top ++ * blocker dialog and goes down to the dialog which is the bottom dialog. ++ * Using another traversal may cause to the flickering issue as a bottom ++ * dialog will cover a top dialog for some period of time. ++ */ ++void AwtDialog::PopupAllDialogs(HWND dialog, BOOL isModalHook, HWND prevFGWindow, BOOL onTaskbar) ++{ ++ HWND blocker = AwtWindow::GetModalBlocker(dialog); ++ BOOL isBlocked = ::IsWindow(blocker); ++ if (isBlocked) { ++ PopupAllDialogs(blocker, isModalHook, prevFGWindow, onTaskbar); ++ } ++ PopupOneDialog(dialog, blocker, isModalHook, prevFGWindow, onTaskbar); ++} ++ ++/* ++ * The function popups the dialog, it distinguishes non-blocked dialogs ++ * and activates the dialogs (sets as foreground window). If the dialog is ++ * blocked, then it changes the Z-order of the dialog. ++ */ ++void AwtDialog::PopupOneDialog(HWND dialog, HWND blocker, BOOL isModalHook, HWND prevFGWindow, BOOL onTaskbar) ++{ ++ if (dialog == AwtToolkit::GetInstance().GetHWnd()) { ++ return; ++ } ++ ++ // fix for 6494032 ++ if (isModalHook && !::IsWindowVisible(dialog)) { ++ ::ShowWindow(dialog, SW_SHOWNA); ++ } ++ ++ BOOL isBlocked = ::IsWindow(blocker); ++ UINT flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE; ++ ++ if (isBlocked) { ++ ::SetWindowPos(dialog, blocker, 0, 0, 0, 0, flags); ++ } else { ++ ::SetWindowPos(dialog, HWND_TOP, 0, 0, 0, 0, flags); ++ // no beep/flash if the mouse was clicked in the taskbar menu ++ // or the dialog is currently inactive ++ if (!isModalHook && !onTaskbar && (dialog == prevFGWindow)) { ++ ::MessageBeep(MB_OK); ++ // some heuristics: 3 times x 64 milliseconds ++ AwtWindow::FlashWindowEx(dialog, 3, 64, FLASHW_CAPTION); ++ } ++ ::BringWindowToTop(dialog); ++ ::SetForegroundWindow(dialog); ++ } ++} ++ + LRESULT CALLBACK AwtDialog::MouseHookProc_NonTT(int nCode, + WPARAM wParam, LPARAM lParam) + { +diff -r 03276203c39c -r 5453a374c1d5 src/windows/native/sun/windows/awt_Dialog.h +--- openjdk.orig/jdk/src/windows/native/sun/windows/awt_Dialog.h Tue Feb 17 10:42:12 2009 +0300 ++++ openjdk/jdk/src/windows/native/sun/windows/awt_Dialog.h Tue Feb 17 14:27:03 2009 +0300 +@@ -113,6 +113,9 @@ + */ + static void ModalPerformActivation(HWND hWnd); + ++ static void PopupAllDialogs(HWND dialog, BOOL isModalHook, HWND prevFGWindow, BOOL onTaskbar); ++ static void PopupOneDialog(HWND dialog, HWND blocker, BOOL isModalHook, HWND prevFGWindow, BOOL onTaskbar); ++ + public: + + // WH_CBT hook procedure used in modality, prevents modal +exporting patch: +<fdopen>