Merge

src/solaris/classes/sun/awt/X11/XListPeer.java

 /*
- * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2003-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
@@ -55,14 +55,15 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
     public final static int     DEFAULT_VISIBLE_ROWS = 4; // From java.awt.List,
     public final static int     HORIZ_SCROLL_AMT = 10;
 
-    final static int
-        PAINT_VSCROLL = 2,
-        PAINT_HSCROLL = 4,
-        PAINT_ITEMS = 8,
-        PAINT_FOCUS = 16,
-        PAINT_BACKGROUND = 32,
-        PAINT_HIDEFOCUS = 64,
-        PAINT_ALL = PAINT_VSCROLL | PAINT_HSCROLL | PAINT_ITEMS | PAINT_FOCUS | PAINT_BACKGROUND;
+    private final static int    PAINT_VSCROLL = 2;
+    private final static int    PAINT_HSCROLL = 4;
+    private final static int    PAINT_ITEMS = 8;
+    private final static int    PAINT_FOCUS = 16;
+    private final static int    PAINT_BACKGROUND = 32;
+    private final static int    PAINT_HIDEFOCUS = 64;
+    private final static int    PAINT_ALL =
+        PAINT_VSCROLL | PAINT_HSCROLL | PAINT_ITEMS | PAINT_FOCUS | PAINT_BACKGROUND;
+    private final static int    COPY_AREA = 128;
 
     XVerticalScrollbar       vsb;
     XHorizontalScrollbar     hsb;
@@ -363,35 +364,6 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
         }
     }
 
-    Area getItemsArea(int firstItem, int lastItem) {
-        firstItem = Math.max(getFirstVisibleItem(), firstItem);
-        lastItem = Math.min(lastItem, getLastVisibleItem());
-        if (lastItem < getFirstVisibleItem()) {
-            return new Area();
-        }
-        if (firstItem <= lastItem) {
-            int startY = getItemY(firstItem);
-            int endY = getItemY(lastItem) + getItemHeight();
-            // Account for focus rectangle, instead should be called twice - before change
-            // of focusIndex and after
-            startY -= 2;
-            endY += 2;
-            // x is 0 since we need to account for focus rectangle,
-            // the same with width
-            return new Area(new Rectangle(0, startY, getItemWidth() + 3, endY-startY+1));
-        } else {
-            return new Area();
-        }
-    }
-
-    Rectangle getItemRect(int item) {
-        return new Rectangle(MARGIN, getItemY(item), getItemWidth(), getItemHeight());
-    }
-
-    Area getItemArea(int item) {
-        return new Area(getItemRect(item));
-    }
-
     public void repaintScrollbarRequest(XScrollbar scrollbar) {
         Graphics g = getGraphics();
         if (scrollbar == hsb)  {
@@ -411,14 +383,36 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
         repaint(getFirstVisibleItem(), getLastVisibleItem(), PAINT_ALL);
     }
 
-    public void repaint(int options) {
+    private void repaint(int options) {
         repaint(getFirstVisibleItem(), getLastVisibleItem(), options);
     }
 
-    public void repaint(int firstItem, int lastItem, int options) {
+    private void repaint(int firstItem, int lastItem, int options) {
+        repaint(firstItem, lastItem, options, null, null);
+    }
+
+    /**
+     * In most cases the entire area of the component doesn't have
+     * to be repainted. The method repaints the particular areas of
+     * the component. The areas to repaint is specified by the option
+     * parameter. The possible values of the option parameter are:
+     * PAINT_VSCROLL, PAINT_HSCROLL, PAINT_ITEMS, PAINT_FOCUS,
+     * PAINT_HIDEFOCUS, PAINT_BACKGROUND, PAINT_ALL, COPY_AREA.
+     *
+     * Note that the COPY_AREA value initiates copy of a source area
+     * of the component by a distance by means of the copyArea method
+     * of the Graphics class.
+     *
+     * @param firstItem the position of the first item of the range to repaint
+     * @param lastItem the position of the last item of the range to repaint
+     * @param options specifies the particular area of the component to repaint
+     * @param source the area of the component to copy
+     * @param distance the distance to copy the source area
+     */
+    private void repaint(int firstItem, int lastItem, int options, Rectangle source, Point distance) {
         Graphics g = getGraphics();
         try {
-            painter.paint(g, firstItem, lastItem, options);
+            painter.paint(g, firstItem, lastItem, options, source, distance);
         } finally {
             g.dispose();
         }
@@ -1449,35 +1443,29 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
         }
         vsb.setValue(vsb.getValue() + y);
 
+        Rectangle source = null;
+        Point distance = null;
+        int firstItem = 0, lastItem = 0;
+        int options = PAINT_HIDEFOCUS | PAINT_ITEMS | PAINT_VSCROLL | PAINT_FOCUS;
         if (y > 0) {
-            // Fixed 6308295: XAWTduplicate list item is displayed
-            // Window resizing leads to the buffer flushing
-            // That's why the repainting with the PAINT_HIDEFOCUS option is the repainting with PAINT_ALL option
-            // So we should do only the repainting instead of the copy area
-            if (y < itemsInWin && painter.isBuffer()) {
-                if (log.isLoggable(Level.FINEST)) {
-                    log.finest("Copying " + "" + MARGIN + "," + ( MARGIN + pixelsToScroll)
-                               + "," +  (width - SCROLLBAR_AREA) + "," +  (h * (itemsInWin - y)-1) +
-                               "," + 0 + "," + (-pixelsToScroll));
-                }
-                // Unpaint focus before copying
-                repaint(PAINT_HIDEFOCUS);
-                painter.copyArea(MARGIN, MARGIN + pixelsToScroll, width - SCROLLBAR_AREA, h * (itemsInWin - y - 1)-1, 0, -pixelsToScroll);
+            if (y < itemsInWin) {
+                source = new Rectangle(MARGIN, MARGIN + pixelsToScroll, width - SCROLLBAR_AREA, h * (itemsInWin - y - 1)-1);
+                distance = new Point(0, -pixelsToScroll);
+                options |= COPY_AREA;
             }
-            repaint(vsb.getValue() + (itemsInWin - y)-1, (vsb.getValue() + itemsInWin) - 1, PAINT_ITEMS | PAINT_VSCROLL | PAINT_FOCUS);
-        } else if (y < 0 && painter.isBuffer()) {
+            firstItem = vsb.getValue() + itemsInWin - y - 1;
+            lastItem = vsb.getValue() + itemsInWin - 1;
+
+        } else if (y < 0) {
             if (y + itemsInWindow() > 0) {
-                if (log.isLoggable(Level.FINEST)) {
-                    log.finest("Copying " + MARGIN + "," + MARGIN +"," +
-                               (width - SCROLLBAR_AREA) + "," +
-                               (h * (itemsInWin + y)) + "," + "0" +"," +(-pixelsToScroll));
-                }
-                repaint(PAINT_HIDEFOCUS);
-                painter.copyArea(MARGIN, MARGIN, width - SCROLLBAR_AREA, h * (itemsInWin + y), 0, -pixelsToScroll);
+                source = new Rectangle(MARGIN, MARGIN, width - SCROLLBAR_AREA, h * (itemsInWin + y));
+                distance = new Point(0, -pixelsToScroll);
+                options |= COPY_AREA;
             }
-            int e = Math.min(getLastVisibleItem(), vsb.getValue() + -y);
-            repaint(vsb.getValue(), e, PAINT_ITEMS | PAINT_VSCROLL | PAINT_FOCUS);
+            firstItem = vsb.getValue();
+            lastItem = Math.min(getLastVisibleItem(), vsb.getValue() + -y);
         }
+        repaint(firstItem, lastItem, options, source, distance);
     }
 
     /**
@@ -1491,12 +1479,17 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
         int h = height - (SCROLLBAR_AREA + (2 * MARGIN));
         hsb.setValue(hsb.getValue() + x);
 
-        if (x < 0 && painter.isBuffer()) {
-            painter.copyArea(MARGIN + SPACE, MARGIN, w + x, h, -x, 0);
-        } else if (x > 0 && painter.isBuffer()) {
-            painter.copyArea(MARGIN + SPACE + x, MARGIN, w - x, h, -x, 0);
+        Rectangle source = null;
+        Point distance = null;
+        if (x < 0) {
+            source = new Rectangle(MARGIN + SPACE, MARGIN, w + x, h);
+            distance = new Point(-x, 0);
+        } else if (x > 0) {
+            source = new Rectangle(MARGIN + SPACE + x, MARGIN, w - x, h);
+            distance = new Point(-x, 0);
         }
-        repaint(vsb.getValue(), lastItemDisplayed(), PAINT_ITEMS | PAINT_HSCROLL);
+        int options = COPY_AREA | PAINT_ITEMS | PAINT_HSCROLL;
+        repaint(vsb.getValue(), lastItemDisplayed(), options, source, distance);
     }
 
     /**
@@ -1677,7 +1670,6 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
      * Since we can't guarantee the sequence, use awtLock.
      */
     class ListPainter {
-        // TODO: use VolatileImage
         VolatileImage buffer;
         Color[] colors;
 
@@ -1746,6 +1738,11 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
         }
 
         private void paint(Graphics listG, int firstItem, int lastItem, int options) {
+            paint(listG, firstItem, lastItem, options, null, null);
+        }
+
+        private void paint(Graphics listG, int firstItem, int lastItem, int options,
+                           Rectangle source, Point distance) {
             if (log.isLoggable(Level.FINER)) log.finer("Repaint from " + firstItem + " to " + lastItem + " options " + options);
             if (firstItem > lastItem) {
                 int t = lastItem;
@@ -1773,17 +1770,34 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
                       invalidate();
                       options = PAINT_ALL;
                       continue;
+                  case VolatileImage.IMAGE_RESTORED:
+                      options = PAINT_ALL;
                 }
                 Graphics g = localBuffer.createGraphics();
 
+                // Note that the order of the following painting operations
+                // should not be modified
                 try {
                     g.setFont(getFont());
+
+                    // hiding the focus rectangle must be done prior to copying
+                    // area and so this is the first action to be performed
+                    if ((options & (PAINT_HIDEFOCUS)) != 0) {
+                        paintFocus(g, PAINT_HIDEFOCUS);
+                    }
+                    /*
+                     * The shift of the component contents occurs while someone
+                     * scrolls the component, the only purpose of the shift is to
+                     * increase the painting performance. The shift should be done
+                     * prior to painting any area (except hiding focus) and actually
+                     * it should never be done jointly with erase background.
+                     */
+                    if ((options & COPY_AREA) != 0) {
+                        g.copyArea(source.x, source.y, source.width, source.height,
+                            distance.x, distance.y);
+                    }
                     if ((options & PAINT_BACKGROUND) != 0) {
-                        g.setColor(SystemColor.window);
-                        g.fillRect(0, 0, width, height);
-                        g.setColor(getListBackground());
-                        g.fillRect(0, 0, listWidth, listHeight);
-                        draw3DRect(g, getSystemColors(), 0, 0, listWidth - 1, listHeight - 1, false);
+                        paintBackground(g);
                         // Since we made full erase update items
                         firstItem = getFirstVisibleItem();
                         lastItem = getLastVisibleItem();
@@ -1799,8 +1813,8 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
                         g.setClip(getHScrollBarRec());
                         paintHorScrollbar(g, true);
                     }
-                    if ((options & (PAINT_FOCUS|PAINT_HIDEFOCUS)) != 0) {
-                        paintFocus(g, options);
+                    if ((options & (PAINT_FOCUS)) != 0) {
+                        paintFocus(g, PAINT_FOCUS);
                     }
                 } finally {
                     g.dispose();
@@ -1809,6 +1823,14 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
             listG.drawImage(localBuffer, 0, 0, null);
         }
 
+        private void paintBackground(Graphics g) {
+            g.setColor(SystemColor.window);
+            g.fillRect(0, 0, width, height);
+            g.setColor(getListBackground());
+            g.fillRect(0, 0, listWidth, listHeight);
+            draw3DRect(g, getSystemColors(), 0, 0, listWidth - 1, listHeight - 1, false);
+        }
+
         private void paintItems(Graphics g, int firstItem, int lastItem, int options) {
             if (log.isLoggable(Level.FINER)) log.finer("Painting items from " + firstItem + " to " + lastItem + ", focused " + focusIndex + ", first " + getFirstVisibleItem() + ", last " + getLastVisibleItem());
 
@@ -1932,53 +1954,5 @@ class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {
             }
             g.setClip(clip);
         }
-
-        public void copyArea(int x, int y, int width, int height, int dx, int dy) {
-            if (log.isLoggable(Level.FINER)) log.finer("Copying area " + x + ", " + y + " " + width +
-                                                       "x" + height + ", (" + dx + "," + dy + ")");
-            VolatileImage localBuffer = null;
-            do {
-                XToolkit.awtLock();
-                try {
-                    if (createBuffer()) {
-                        // Newly created buffer should be painted over at full
-                        repaint(PAINT_ALL);
-                        return;
-                    }
-                    localBuffer = buffer;
-                } finally {
-                    XToolkit.awtUnlock();
-                }
-                switch (localBuffer.validate(getGraphicsConfiguration())) {
-                  case VolatileImage.IMAGE_INCOMPATIBLE:
-                      invalidate();
-                  case VolatileImage.IMAGE_RESTORED:
-                      // Since we've lost the content we can't just scroll - we should paint again
-                      repaint(PAINT_ALL);
-                      return;
-                }
-                Graphics g = localBuffer.createGraphics();
-                try {
-                    g.copyArea(x, y, width, height, dx, dy);
-                } finally {
-                    g.dispose();
-                }
-            } while (localBuffer.contentsLost());
-            Graphics listG = getGraphics();
-            listG.setClip(x, y, width, height);
-            listG.drawImage(localBuffer, 0, 0, null);
-            listG.dispose();
-        }
-
-        public boolean isBuffer() {
-            boolean isBuffer;
-            XToolkit.awtLock();
-            try {
-                isBuffer = (buffer != null);
-            } finally {
-                XToolkit.awtUnlock();
-            }
-            return isBuffer;
-        }
     }
 }

test/java/awt/Insets/WindowWithWarningTest/WindowWithWarningTest.html

+<html>
+<!--
+        @test
+        @bug 6391770
+        @summary Content of the Window should be laid out in the area left after WarningWindow was added.
+        @author Yuri Nesterenko
+        @run applet WindowWithWarningTest.html
+-->
+
+  <head>
+    <title>WindowWithWarningTest</title>
+  </head>
+  <pre>
+  This test will run automatically.
+  </pre>
+  <body>
+    <applet code="WindowWithWarningTest.class" width=350 height=300></applet>
+  </body>
+</html>
+

test/java/awt/Insets/WindowWithWarningTest/WindowWithWarningTest.java

+/*
+ * Copyright 2006-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 6391770
+  @summary Content of the Window should be laid out in the area left after WarningWindow was added.
+  @author yuri nesterenko: area=
+  @run applet WindowWithWarningTest.html
+*/
+
+// Note there is no @ in front of test above.  This is so that the
+//  harness will not mistake this file as a test file.  It should
+//  only see the html file as a test file. (the harness runs all
+//  valid test files, so it would run this test twice if this file
+//  were valid as well as the html file.)
+// Also, note the area= after Your Name in the author tag.  Here, you
+//  should put which functional area the test falls in.  See the
+//  AWT-core home page -> test areas and/or -> AWT team  for a list of
+//  areas.
+// Note also the 'AutomaticAppletTest.html' in the run tag.  This should
+//  be changed to the name of the test.
+
+
+/**
+ * WindowWithWarningTest.java
+ *
+ * summary:
+ */
+
+import java.applet.Applet;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+//Automated tests should run as applet tests if possible because they
+// get their environments cleaned up, including AWT threads, any
+// test created threads, and any system resources used by the test
+// such as file descriptors.  (This is normally not a problem as
+// main tests usually run in a separate VM, however on some platforms
+// such as the Mac, separate VMs are not possible and non-applet
+// tests will cause problems).  Also, you don't have to worry about
+// synchronisation stuff in Applet tests they way you do in main
+// tests...
+
+
+public class WindowWithWarningTest extends Applet
+{
+    //Declare things used in the test, like buttons and labels here
+    boolean buttonClicked = false;
+    public static final int MAX_COUNT = 100;
+
+    public void init()
+    {
+        //Create instructions for the user here, as well as set up
+        // the environment -- set the layout manager, add buttons,
+        // etc.
+
+        this.setLayout (new BorderLayout ());
+
+        String[] instructions =
+        {
+            "This is an AUTOMATIC test",
+            "simply wait until it is done"
+        };
+        //Sysout.createDialog( );
+        //Sysout.printInstructions( instructions );
+
+    }//End  init()
+    public void start ()
+    {
+        //Get things going.  Request focus, set size, et cetera
+        System.setSecurityManager( new SecurityManager() {
+        // deny AWTPermission("showWindowWithoutWarningBanner")
+            public boolean checkTopLevelWindow(Object window) {
+                return false;
+            }
+         });
+        JFrame frame = new JFrame("Window Test");
+        frame.setBounds(50, 50, 200, 200);
+        frame.show();
+
+        JWindow window = new JWindow( frame );
+        JButton jbutton1 = new JButton( "First" );
+        jbutton1.addMouseListener( new MouseAdapter() {
+            public void mousePressed( MouseEvent me ) {
+                buttonClicked = true;
+            }
+         });
+        JButton jbutton2 = new JButton( "Second" );
+        window.setLocation( 300, 300 );
+
+        window.add("North", jbutton1);
+        window.add("South", jbutton2);
+
+        window.pack();
+        window.show();
+        //wait for frame to show:
+        getLocation( frame );
+        window.toFront();
+
+        Dimension size0 = window.getSize();
+        Dimension size1 = null;
+        try {
+            Robot robot = new Robot();
+
+            robot.delay(500);
+            window.pack();
+            robot.delay(500);
+            window.pack();
+            // size1 must be the same as size0
+            size1 = window.getSize();
+            robot.delay(500);
+            Point pt = jbutton1.getLocationOnScreen();
+            robot.mouseMove((int) jbutton1.getLocationOnScreen().x + jbutton1.getWidth() / 2,
+                            (int) jbutton1.getLocationOnScreen().y + jbutton1.getHeight() / 2);
+            robot.delay(500);
+            robot.mousePress(MouseEvent.BUTTON1_MASK);
+            robot.delay(100);
+            robot.mouseRelease(MouseEvent.BUTTON1_MASK);
+            robot.delay(2000);
+         }catch(Exception e) {
+            throw new RuntimeException( "Exception "+e );
+         }
+         if( !size0.equals(size1) ) {
+            throw new RuntimeException( "Wrong Window size after multiple pack()s");
+         }
+         if( !buttonClicked ) {
+            throw new RuntimeException( "Button was not clicked");
+         }
+         window.dispose();
+         frame.dispose();
+
+         System.out.println("Test Passed.");
+    }// start()
+    public static Point getLocation( Component co ) throws RuntimeException {
+       Point pt = null;
+       boolean bFound = false;
+       int count = 0;
+       while( !bFound ) {
+          try {
+             pt = co.getLocationOnScreen();
+             bFound = true;
+          }catch( Exception ex ) {
+             bFound = false;
+             count++;
+          }
+          if( !bFound && count > MAX_COUNT ) {
+             throw new RuntimeException("don't see a component to get location");
+          }
+       }
+       return pt;
+    }
+
+
+}// class AutomaticAppletTest
+
+
+/****************************************************
+ 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
+{
+
+    TextArea instructionsText;
+    TextArea messageText;
+    int maxStringLength = 80;
+
+    //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);
+
+        pack();
+
+        show();
+    }// 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);
+    }
+
+}// TestDialog  class

test/java/awt/List/ListFlickers/ListFlickers.java

+/*
+ * 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 6471693
+  @summary Moving the vertical scroll bar of List leads flickering.
+  @author Dmitry Cherepanov area=awt.list
+  @run main/manual ListFlickers
+*/
+
+import java.awt.*;
+import java.awt.event.*;
+
+public class ListFlickers
+{
+
+    //*** test-writer defined static variables go here ***
+
+
+    private static void init()
+    {
+        //*** Create instructions for the user here ***
+
+        String[] instructions =
+        {
+            "drag the scrollbar of the list up and down,",
+            "if the list flickers then the test fails,",
+            "otherwise it passes."
+        };
+        Sysout.createDialog( );
+        Sysout.printInstructions( instructions );
+
+
+        Frame f = new Frame();
+        List list = new List(10, false);
+        for (int i = 0; i < 100; i++) {
+            list.add(" item "+i);
+        }
+        f.add(list);
+        f.setBounds(100,100,300,300);
+        f.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;
+        if (mainThread != null){
+            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;
+    private static boolean numbering = false;
+    private static int messageNumber = 0;
+
+    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." );
+    }
+
+
+    /* Enables message counting for the tester. */
+    public static void enableNumbering(boolean enable){
+        numbering = enable;
+    }
+
+    public static void printInstructions( String[] instructions )
+    {
+        dialog.printInstructions( instructions );
+    }
+
+
+    public static void println( String messageIn )
+    {
+        if (numbering) {
+            messageIn = "" + messageNumber + " " + messageIn;
+            messageNumber++;
+        }
+        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" )
+        {
+            ListFlickers.pass();
+        }
+        else
+        {
+            ListFlickers.fail();
+        }
+    }
+
+}// TestDialog  class

test/java/awt/TextField/ScrollSelectionTest/ScrollSelectionTest.html

+<html>
+<!--  
+  @test
+  @bug 4118621
+  @summary tests that selected text isn't scrolled if there is enough room.
+  @author prs: area=TextField
+  @run applet/manual=yesno ScrollSelectionTest.html
+  -->
+<head>
+<title> ScrollSelectionTest </title>
+</head>
+<body>
+
+<h1>ScrollSelectionTest<br>4118621: </h1>
+
+<p> See the dialog box (usually in upper left corner) for instructions</p>
+
+<APPLET CODE="ScrollSelectionTest.class" WIDTH=300 HEIGHT=300></APPLET>
+</body>
+</html>

test/java/awt/TextField/ScrollSelectionTest/ScrollSelectionTest.java

+/*
+ * Copyright 1999-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 4118621
+  @summary tests that selected text isn't scrolled when there is enough room.
+  @author prs: area=TextField
+  @run applet/manual=yesno ScrollSelectionTest.html
+*/
+
+/**
+ * ScrollSelectionTest.java
+ *
+ * summary: tests that selected text isn't scrolled when there is enough room.
+ */
+
+import java.applet.Applet;
+import java.awt.Dialog;
+import java.awt.Frame;
+import java.awt.TextField;
+import java.awt.TextArea;
+
+public class ScrollSelectionTest extends Applet
+ {
+
+   Frame frame = new Frame("ScrollSelectionTest frame");
+   TextField tf = new TextField(40);
+
+   public void init()
+    {
+      tf.setText("abcdefghijklmnopqrstuvwxyz");
+      frame.add(tf);
+      tf.select(0, 20);
+
+      String[] instructions =
+       {
+          "INSTRUCTIONS:",
+          "This is a test for a win32 specific problem",
+          "If you see all the letters from 'a' to 'z' and",
+          "letters from 'a' to 't' are selected then test passes"
+       };
+      Sysout.createDialogWithInstructions( instructions );
+
+    }// init()
+
+   public void start ()
+    {
+      setSize (300,300);
+      setVisible(true);
+
+      frame.setVisible(true);
+      frame.setBounds (400, 0, 300, 300);
+
+    }// start()
+
+ }// class ScrollSelectionTest
+
+/****************************************************
+ 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.show();
+      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.show();
+      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
+ {
+
+   TextArea instructionsText;
+   TextArea messageText;
+   int maxStringLength = 80;
+
+   //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("South", messageText);
+
+      pack();
+
+      show();
+    }// 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" );
+    }
+
+ }// TestDialog  class

test/java/awt/xembed/server/JavaClient.java

+/*
+ * Copyright 2004-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.
+ */
+
+import java.awt.*;
+import sun.awt.*;
+import java.awt.event.*;
+import java.lang.reflect.*;
+import java.awt.dnd.*;
+import java.awt.datatransfer.*;
+
+public class JavaClient {
+    ClientContainer cont;
+    public static void main(String[] args) {
+        if (System.getProperty("os.name").toLowerCase().startsWith("win")) {
+            return;
+        }
+
+        // Enable testing extensions in XEmbed server
+        System.setProperty("sun.awt.xembed.testing", "true");
+
+        boolean xtoolkit = "sun.awt.X11.XToolkit".equals(Toolkit.getDefaultToolkit().getClass().getName());
+        final EmbeddedFrame ef = createEmbeddedFrame(xtoolkit, Long.parseLong(args[0]));
+        ef.setBackground(new Color(100, 100, 200));
+        ef.setLayout(new BorderLayout());
+        ef.add(new ClientContainer(ef), BorderLayout.CENTER);
+        ef.pack();
+        ef.registerListeners();
+        ef.setVisible(true);
+    }
+    private static EmbeddedFrame createEmbeddedFrame(boolean xtoolkit, long window) {
+        try {
+            Class cl = (xtoolkit?Class.forName("sun.awt.X11.XEmbeddedFrame"):Class.forName("sun.awt.motif.MEmbeddedFrame"));
+            Constructor cons = cl.getConstructor(new Class[]{Long.TYPE, Boolean.TYPE});
+            return (EmbeddedFrame)cons.newInstance(new Object[] {window, true});
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException("Can't create embedded frame");
+        }
+    }
+}
+
+class ClientContainer extends Container {
+    Window parent;
+    int width, height;
+    public ClientContainer(Window w) {
+        parent = w;
+        width = 500;
+        height = 50;
+        final TextField tf = new TextField(30);
+
+        DragSource ds = new DragSource();
+        final DragSourceListener dsl = new DragSourceAdapter() {
+                public void dragDropEnd(DragSourceDropEvent dsde) {
+                }
+            };
+        final DragGestureListener dgl = new DragGestureListener() {
+                public void dragGestureRecognized(DragGestureEvent dge) {
+                    dge.startDrag(null, new StringSelection(tf.getText()), dsl);
+                }
+            };
+        ds.createDefaultDragGestureRecognizer(tf, DnDConstants.ACTION_COPY, dgl);
+
+        final DropTargetListener dtl = new DropTargetAdapter() {
+                public void drop(DropTargetDropEvent dtde) {
+                    dtde.acceptDrop(DnDConstants.ACTION_COPY);
+                    try {
+                        tf.setText(tf.getText() + (String)dtde.getTransferable().getTransferData(DataFlavor.stringFlavor));
+                    } catch (Exception e) {
+                    }
+                }
+            };
+        final DropTarget dt = new DropTarget(tf, dtl);
+
+        setLayout(new FlowLayout());
+        add(tf);
+        Button close = new Button("Close");
+        close.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    parent.dispose();
+                }
+            });
+        Button inc = new Button("Increase size");
+        inc.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    changeSize(10);
+                }
+            });
+        Button dec = new Button("Decrease size");
+        dec.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    changeSize(-10);
+                }
+            });
+        add(close);
+        add(inc);
+        add(dec);
+    }
+    void changeSize(int step) {
+        width += step;
+        height += step;
+        parent.pack();
+    }
+    public Dimension getPreferredSize() {
+        return new Dimension(width, height);
+    }
+}

test/java/awt/xembed/server/RunTestXEmbed.java

+/*
+ * Copyright 2004-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 4931668
+ * @summary Tests XEmbed server/client functionality
+ * @author Denis Mikhalkin: area=awt.xembed
+ * @compile JavaClient.java TesterClient.java TestXEmbedServer.java
+ * @run main/timeout=6000 RunTestXEmbed
+ */
+
+import java.awt.Rectangle;
+import java.lang.reflect.Method;
+import java.util.logging.*;
+import java.util.*;
+import java.io.*;
+
+public class RunTestXEmbed extends TestXEmbedServer {
+    private static final Logger log = Logger.getLogger("test.xembed");
+    private Method test;
+    private boolean passed = false;
+    public RunTestXEmbed(Method test) {
+        super(false);
+        this.test = test;
+    }
+
+    public Process startClient(Rectangle bounds[], long window) {
+        try {
+            String java_home = System.getProperty("java.home");
+            StringBuilder buf = new StringBuilder();
+            for (int i = 0; i < bounds.length; i++) {
+                buf.append(" " + bounds[i].x);
+                buf.append(" " + bounds[i].y);
+                buf.append(" " + bounds[i].width);
+                buf.append(" " + bounds[i].height);
+            }
+            Map envs = System.getenv();
+            String enva[] = new String[envs.size()];
+            int ind = 0;
+            Iterator iter = envs.entrySet().iterator();
+            while (iter.hasNext()) {
+                Map.Entry entry = (Map.Entry)iter.next();
+                if (!"AWT_TOOLKIT".equals(entry.getKey())) {
+                    enva[ind++] = entry.getKey() + "=" + entry.getValue();
+                } else {
+                    enva[ind++] = "AWT_TOOLKIT=sun.awt.X11.XToolkit";
+                }
+            }
+            Process proc = Runtime.getRuntime().exec(java_home +
+                                                     "/bin/java -Dawt.toolkit=sun.awt.X11.XToolkit TesterClient "
+                                                     + test.getName() + " " + window + buf,
+                                                     enva);
+            System.err.println("Test for " + test.getName() + " has started.");
+            log.fine("Test for " + test.getName() + " has started.");
+            new InputReader(proc.getInputStream());
+            new InputReader(proc.getErrorStream());
+            try {
+                passed = (proc.waitFor() == 0);
+            } catch (InterruptedException ie) {
+            }
+            log.fine("Test for " + test.getName() + " has finished.");
+            File logFile = new File("java3.txt");
+            if (logFile.exists()) {
+                logFile.renameTo(new File(test.getName() + ".txt"));
+            }
+            return proc;
+        } catch (IOException ex1) {
+            ex1.printStackTrace();
+        }
+        return null;
+    }
+
+    public static void main(String[] args) throws Throwable {
+        if (System.getProperty("os.name").toLowerCase().startsWith("win")) {
+            return;
+        }
+
+        // Enabled XEmbed
+        System.setProperty("sun.awt.xembedserver", "true");
+
+        if (args.length == 1) {
+            Class cl = Class.forName("sun.awt.X11.XEmbedServerTester");
+            Method meth = cl.getMethod(args[0], new Class[0]);
+            System.err.println("Performing single test " + args[0]);
+            boolean res = performTest(meth);
+            if (!res) {
+                System.err.println("Test " + args[0] + " has failed");
+            } else {
+                System.err.println("Test " + args[0] + " has passed");
+            }
+        } else {
+            Class cl = Class.forName("sun.awt.X11.XEmbedServerTester");
+            Method[] meths = cl.getMethods();
+            LinkedList failed = new LinkedList();
+            for (int i = 0; i < meths.length; i++) {
+                Method meth = meths[i];
+                if (meth.getReturnType() == Void.TYPE && meth.getName().startsWith("test") && meth.getParameterTypes().length == 0) {
+                    System.err.println("Performing " + meth.getName());
+                    boolean res = performTest(meth);
+                    if (!res) {
+                        failed.add(meth);
+                    }
+                }
+            }
+            log.info("Testing finished.");
+            if (failed.size() != 0) {
+                System.err.println("Some tests have failed:");
+                Iterator iter = failed.iterator();
+                while(iter.hasNext()) {
+                    Method meth = (Method)iter.next();
+                    System.err.println(meth.getName());
+                }
+                throw new RuntimeException("TestFAILED: some of the testcases are failed");
+            } else {
+                System.err.println("All PASSED");
+            }
+        }
+    }
+
+    private static boolean performTest(Method meth) {
+        RunTestXEmbed test = new RunTestXEmbed(meth);
+        test.addClient();
+        test.dispose();
+        return test.isPassed();
+    }
+
+    public boolean isPassed() {
+        return passed;
+    }
+}
+
+class InputReader extends Thread {
+    private InputStream stream;
+    public InputReader(InputStream stream) {
+        this.stream = stream;
+        start();
+    }
+    public void run() {
+        while (!interrupted()) {
+            try {
+                int inp = stream.read();
+                if (inp != -1) {
+                    System.out.write(inp);
+                } else {
+                    try {
+                        Thread.sleep(100);
+                    } catch (Exception iie) {
+                    }
+                }
+            } catch (IOException ie) {
+                break;
+            }
+        }
+    }
+}

test/java/awt/xembed/server/TestXEmbedServer.java

+/*
+ * Copyright 2004-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.
+ */
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.io.*;
+import java.util.logging.*;
+import sun.awt.WindowIDProvider;
+import java.awt.dnd.*;
+import java.awt.datatransfer.*;
+
+public abstract class TestXEmbedServer {
+    private static final Logger log = Logger.getLogger("test.xembed");
+    Frame f;
+    Canvas client;
+    Button toFocus;
+    Button b_modal;
+    JButton b_close;
+    JDialog modal_d;
+    JFrame dummy;
+    Container clientCont;
+    boolean passed;
+
+    public boolean isPassed() {
+        return passed;
+    }
+
+    public TestXEmbedServer(boolean manual) {
+
+        // Enable testing extensions in XEmbed server
+        System.setProperty("sun.awt.xembed.testing", "true");
+
+        f = new Frame("Main frame");
+        f.addWindowListener(new WindowAdapter() {
+                public void windowClosing(WindowEvent e) {
+                    synchronized(TestXEmbedServer.this) {
+                        TestXEmbedServer.this.notifyAll();
+                    }
+                    dummy.dispose();
+                    f.dispose();
+                }
+            });
+
+        f.setLayout(new BorderLayout());
+
+        Container bcont = new Container();
+
+        toFocus = new Button("Click to focus server");
+        final TextField tf = new TextField(20);
+        tf.setName("0");
+        DragSource ds = new DragSource();
+        final DragSourceListener dsl = new DragSourceAdapter() {
+                public void dragDropEnd(DragSourceDropEvent dsde) {
+                }
+            };
+        final DragGestureListener dgl = new DragGestureListener() {
+                public void dragGestureRecognized(DragGestureEvent dge) {
+                    dge.startDrag(null, new StringSelection(tf.getText()), dsl);
+                }
+            };
+        ds.createDefaultDragGestureRecognizer(tf, DnDConstants.ACTION_COPY, dgl);
+
+        final DropTargetListener dtl = new DropTargetAdapter() {
+                public void drop(DropTargetDropEvent dtde) {
+                    dtde.acceptDrop(DnDConstants.ACTION_COPY);
+                    try {
+                        tf.setText(tf.getText() + (String)dtde.getTransferable().getTransferData(DataFlavor.stringFlavor));
+                    } catch (Exception e) {
+                    }
+                }
+            };
+        final DropTarget dt = new DropTarget(tf, dtl);
+
+        Button b_add = new Button("Add client");
+        b_add.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    addClient();
+                }
+            });
+        Button b_remove = new Button("Remove client");
+        b_remove.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    if (clientCont.getComponentCount() != 0) {
+                        clientCont.remove(clientCont.getComponentCount()-1);
+                    }
+                }
+            });
+        b_close = new JButton("Close modal dialog");
+        b_close.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    modal_d.dispose();
+                }
+            });
+        b_modal = new Button("Show modal dialog");
+        b_modal.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    modal_d = new JDialog(f, "Modal dialog", true);
+                    modal_d.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+                    modal_d.setBounds(0, 100, 200, 50);
+                    modal_d.getContentPane().add(b_close);
+                    modal_d.validate();
+                    modal_d.show();
+                }
+            });
+
+        bcont.add(tf);
+        bcont.add(toFocus);
+        bcont.add(b_add);
+        bcont.add(b_remove);
+        bcont.add(b_modal);
+        if (manual) {
+            Button pass = new Button("Pass");
+            pass.addActionListener(new ActionListener() {
+                    public void actionPerformed(ActionEvent e) {
+                        passed = true;
+                        synchronized(TestXEmbedServer.this) {
+                            TestXEmbedServer.this.notifyAll();
+                        }
+                    }
+                });
+            bcont.add(pass);
+            Button fail = new Button("Fail");
+            fail.addActionListener(new ActionListener() {
+                    public void actionPerformed(ActionEvent e) {
+                        passed = false;
+                        synchronized(TestXEmbedServer.this) {
+                            TestXEmbedServer.this.notifyAll();
+                        }
+                    }
+                });
+            bcont.add(fail);
+        }
+        b_modal.setName("2");
+        bcont.setLayout(new FlowLayout());
+        f.add(bcont, BorderLayout.NORTH);
+
+        clientCont = Box.createVerticalBox();
+        f.add(clientCont, BorderLayout.CENTER);
+
+        dummy = new JFrame("Dummy");
+        dummy.getContentPane().add(new JButton("Button"));
+        dummy.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        dummy.setBounds(0, 0, 100, 100);
+        dummy.setVisible(true);
+
+        f.setBounds(300, 0, 800, 300);
+        f.setVisible(true);
+    }
+
+    public abstract Process startClient(Rectangle bounds[], long window);
+
+    public void addClient() {
+        client = new Canvas() {
+                public void paint(Graphics g) {
+                    super.paint(g);
+                }
+            };
+        client.setBackground(new Color(30, 220, 40));
+        clientCont.add(client);
+        clientCont.validate();
+        WindowIDProvider pid = (WindowIDProvider)client.getPeer();
+        log.fine("Added XEmbed server(Canvas) with X window ID " + pid.getWindow());
+        Rectangle toFocusBounds = toFocus.getBounds();
+        toFocusBounds.setLocation(toFocus.getLocationOnScreen());
+        f.validate();
+
+        // KDE doesn't accept clicks on title as activation - click below title
+        Rectangle fbounds = f.getBounds();
+        fbounds.y += f.getInsets().top;
+        fbounds.height -= f.getInsets().top;
+
+        Process proc = startClient(new Rectangle[] {fbounds, dummy.getBounds(), toFocusBounds,
+                                                    new Rectangle(b_modal.getLocationOnScreen(), b_modal.getSize()),
+                                                    new Rectangle(10, 130, 20, 20)}, pid.getWindow());
+        new ClientWatcher(client, proc, clientCont).start();
+    }
+
+    public void dispose() {
+        f.dispose();
+        f = null;
+        dummy.dispose();
+        dummy = null;
+        if (modal_d != null) {
+            modal_d.dispose();
+            modal_d = null;
+        }
+    }
+}
+
+class ClientWatcher extends Thread {
+    private Process clientProcess;
+    private Canvas client;
+    private Container parent;
+    public ClientWatcher(Canvas client, Process proc, Container parent) {
+        this.client = client;
+        this.clientProcess = proc;
+        this.parent = parent;
+    }
+
+    public void run() {
+        try {
+            clientProcess.waitFor();
+        } catch (InterruptedException ie) {
+        }
+        parent.remove(client);
+    }
+}

test/java/awt/xembed/server/TestXEmbedServerJava.java

+/*
+ * Copyright 2004-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 4931668
+ * @summary Tests XEmbed server/client functionality
+ * @author denis mikhalkin: area=awt.xembed
+ * @compile JavaClient.java TesterClient.java TestXEmbedServer.java
+ * @run main/manual TestXEmbedServerJava
+ */
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.io.*;
+
+public class TestXEmbedServerJava extends TestXEmbedServer {
+    public static void main(String[] args) {
+        if (System.getProperty("os.name").toLowerCase().startsWith("win")) {
+            return;
+        }
+
+        // Enabled XEmbed
+        System.setProperty("sun.awt.xembedserver", "true");
+
+        String instruction =
+            "This is a manual test for XEmbed server functionality. \n" +
+            "You may start XEmbed client by pressing 'Add client' button.\n" +
+            "Check that focus transfer with mouse works, that focus traversal with Tab/Shift-Tab works.\n" +
+            "Check that XEmbed server client's growing and shrinking.\n" +
+            "Check that Drag&Drop works in all combinations.\n" +
+            "Check the keyboard input works in both text fields.\n";
+        Frame f = new Frame("Instructions");
+        f.setLayout(new BorderLayout());
+        f.add(new TextArea(instruction), BorderLayout.CENTER);
+        f.pack();
+        f.setLocation(0, 400);
+        f.setVisible(true);
+
+        TestXEmbedServerJava lock = new TestXEmbedServerJava();
+        try {
+            synchronized(lock) {
+                lock.wait();
+            }
+        } catch (InterruptedException e) {
+        }
+        if (!lock.isPassed()) {
+            throw new RuntimeException("Test failed");
+        }
+    }
+
+    public TestXEmbedServerJava() {
+        super(true);
+    }
+
+    public Process startClient(Rectangle[] bounds, long window) {
+        try {
+            String java_home = System.getProperty("java.home");
+            return Runtime.getRuntime().exec(java_home + "/bin/java JavaClient " + window);
+        } catch (IOException ex1) {
+            ex1.printStackTrace();
+        }
+        return null;
+    }
+}

test/java/awt/xembed/server/TesterClient.java

+/*
+ * Copyright 2004-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.
+ */
+
+import java.lang.reflect.*;
+import java.awt.Rectangle;
+import java.util.logging.*;
+
+public class TesterClient {
+    private static final Logger log = Logger.getLogger("test.xembed.TesterClient");
+    private static Method test;
+    private static boolean passed = false;
+    public static void main(String[] args) throws Throwable {
+        // First parameter is the name of the test, second is the window, the rest are rectangles
+        Class cl = Class.forName("sun.awt.X11.XEmbedServerTester");
+        test = cl.getMethod(args[0], new Class[0]);
+        long window = Long.parseLong(args[1]);
+        Rectangle r[] = new Rectangle[(args.length-2)/4];
+        for (int i = 0; i < r.length; i++) {
+            r[i] = new Rectangle(Integer.parseInt(args[2+i*4]), Integer.parseInt(args[2+i*4+1]),
+                                 Integer.parseInt(args[2+i*4+2]), Integer.parseInt(args[2+i*4+3]));
+        }
+        startClient(r, window);
+    }
+
+    public static void startClient(Rectangle bounds[], long window) throws Throwable {
+        Method m_getTester = Class.forName("sun.awt.X11.XEmbedServerTester").
+            getMethod("getTester", new Class[] {bounds.getClass(), Long.TYPE});
+        final Object tester = m_getTester.invoke(null, new Object[] {bounds, window});
+        try {
+            log.info("Starting test " + test.getName());
+            test.invoke(tester, (Object[])null);
+            log.info("Test " + test.getName() + " PASSED.");
+            passed = true;
+        } catch (Exception e) {
+            log.log(Level.WARNING, "Test " + test.getName() + " FAILED.", e);
+        }
+        System.exit(passed?0:1);
+    }
+}