Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 1115 insertions, 0 deletions

diff --git a/bean/qa/complex/bean/OOoBeanTest.java b/bean/qa/complex/bean/OOoBeanTest.java
new file mode 100644
index 000000000..0e23e1701
--- /dev/null
+++ b/bean/qa/complex/bean/OOoBeanTest.java
@@ -0,0 +1,684 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+package complex.bean;
+
+
+import java.awt.event.*;
+
+import com.sun.star.comp.beans.OOoBean;
+import com.sun.star.uno.UnoRuntime;
+
+import java.awt.*;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.openoffice.test.OfficeConnection;
+
+import static org.junit.Assert.*;
+
+/**
+ * This only here to expose the protected constructor.
+ */
+class PrivateLocalOfficeConnection extends com.sun.star.comp.beans.LocalOfficeConnection
+{
+    public PrivateLocalOfficeConnection(com.sun.star.uno.XComponentContext xContext)
+    {
+        super(xContext);
+    }
+}
+
+@Deprecated
+public class OOoBeanTest
+{
+
+    /** For X-Windows we need to prolong the time between painting windows. Because
+        it takes longer than on Windows.
+    */
+    private int getSleepTime(int time)
+    {
+        if (!isWindows())
+        {
+            return time * 5;
+        }
+        return time;
+    }
+
+    /** If it cannot be determined if we run on Windows then we assume
+        that we do not.
+    */
+    private boolean isWindows()
+    {
+        boolean ret = false;
+        String os = System.getProperty("os.name");
+        if (os != null)
+        {
+            os = os.trim();
+            if (os.toLowerCase().indexOf("win") == 0)
+            {
+                ret = true;
+            }
+        }
+        return ret;
+    }
+
+    private String getText(OOoBean bean) throws Exception
+    {
+        com.sun.star.frame.XModel model = bean.getDocument();
+        com.sun.star.text.XTextDocument myDoc =
+            UnoRuntime.queryInterface(com.sun.star.text.XTextDocument.class, model);
+        com.sun.star.text.XText xText = myDoc.getText();
+        return xText.getString();
+    }
+
+    /** 1.Create a Java frame
+     *  2.Add OOoBean (no document loaded yet)
+     *  3.Show frame
+     *  4.Load document
+     */
+    @Test public void test1() throws Exception
+    {
+        WriterFrame f = null;
+        try
+        {
+            f = new WriterFrame(100 ,100, 500 ,400, false, connection.getComponentContext());
+            f.setText("OOoBean test.");
+            Thread.sleep(1000);
+        }
+        finally
+        {
+            if (f != null)
+            {
+                f.dispose();
+            }
+        }
+    }
+
+    /** Sizing, painting
+     */
+    @Test public void test2() throws Exception
+    {
+        WriterFrame f = null;
+        ScreenComparer capturer = null;
+        try
+        {
+            f = new WriterFrame(100, 100, 500,500, false, connection.getComponentContext());
+            if (!f.checkUnoFramePosition())
+            {
+                fail("Sizing error: Client are of Java frame does not match the UNO window.");
+            }
+            capturer = new ScreenComparer(100, 100, 500, 500);
+
+            //Minimize Window and back
+            f.goToStart();
+            f.pageDown();
+            Thread.sleep(1000);
+            for (int i = 0; i < 3; i++)
+            {
+                capturer.reset();
+                capturer.grabOne(f.getClientArea());
+                f.setExtendedState(Frame.ICONIFIED);
+                Thread.sleep(getSleepTime(200));
+                if (!f.checkUnoFramePosition())
+                {
+                    fail("Sizing error: Frame was iconified.");
+                }
+                f.setExtendedState(Frame.NORMAL);
+                Thread.sleep(getSleepTime(200));
+                if (!f.checkUnoFramePosition())
+                {
+                    fail("Sizing error: Frame size set back to normal after it was iconified.");
+                }
+                capturer.grabTwo(f.getClientArea());
+                if (!capturer.compare())
+                {
+                    fail("Painting error: Minimize (iconify) frame and back to normal size.");
+                    capturer.writeImages();
+                }
+            }
+
+            //Maximize Window and back to normal
+            for (int i = 0; i < 3; i++)
+            {
+                capturer.reset();
+                capturer.grabOne(f.getClientArea());
+                f.setExtendedState(Frame.MAXIMIZED_BOTH);
+                Thread.sleep(getSleepTime(200));
+                if (!f.checkUnoFramePosition())
+                {
+                    fail("Sizing error: Frame maximized.");
+                }
+                f.setExtendedState(Frame.NORMAL);
+                Thread.sleep(getSleepTime(200));
+                if (!f.checkUnoFramePosition())
+                {
+                    fail("Sizing error: Frame set from maximized to normal.");
+                }
+                capturer.grabTwo(f.getClientArea());
+                if (!capturer.compare())
+                {
+                    fail("Painting error: Maximize frame and back to normal size");
+                    capturer.writeImages();
+                }
+            }
+
+            //move Window top left
+            capturer.reset();
+            capturer.grabOne(f.getClientArea());
+            Rectangle oldPosition = f.getBounds();
+            f.setBounds(0, 0, oldPosition.width, oldPosition.height);
+            Thread.sleep(getSleepTime(200));
+            if (!f.checkUnoFramePosition())
+            {
+                fail("Sizing error: Frame moved.");
+            }
+
+            capturer.grabTwo(f.getClientArea());
+            if (!capturer.compare())
+            {
+                fail("Painting error: Move frame to a different position.");
+                capturer.writeImages();
+            }
+
+            //move Window down
+            Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
+            int maxY = dim.height - f.getBounds().height;
+
+            int curY = 0;
+            while (curY < maxY)
+            {
+                capturer.reset();
+                capturer.grabOne(f.getClientArea());
+                oldPosition = f.getBounds();
+                f.setBounds(0, curY, oldPosition.width, oldPosition.height);
+                capturer.grabTwo(f.getClientArea());
+                if (!capturer.compare())
+                {
+                    fail("Painting error: Move frame to a different position.");
+                    capturer.writeImages();
+                }
+                curY+= 50;
+                Thread.sleep(getSleepTime(200));
+            }
+
+            //obscure the window and make it visible again
+
+            oldPosition = f.getBounds();
+
+            Rectangle pos = new Rectangle(oldPosition.x - 50, oldPosition.y - 50,
+                                          oldPosition.width, oldPosition.height);
+            Frame coverFrame = new Frame();
+            coverFrame.setBounds(pos);
+            capturer.reset();
+            capturer.grabOne(f.getClientArea());
+
+            for (int i = 0; i < 3; i++)
+            {
+                coverFrame.setVisible(true);
+                Thread.sleep(getSleepTime(200));
+                f.toFront();
+                Thread.sleep(getSleepTime(200));
+                if (!f.checkUnoFramePosition())
+                {
+                    fail("Sizing error: Frame moved from back to front.");
+                }
+
+                capturer.grabTwo(f.getClientArea());
+                if (!capturer.compare())
+                {
+                    fail("Painting error: Move frame to back and to front.");
+                    capturer.writeImages();
+                }
+            }
+
+            coverFrame.dispose();
+        }
+        finally
+        {
+            if (f != null)
+            {
+                f.dispose();
+            }
+        }
+    }
+
+    /**
+       1. Create an OOoBean
+       2. Load a document
+       3. Create Frame (do not show yet)
+       4. Add OOoBean to Frame
+       5. Show Frame
+     */
+    @Test public void test3() throws Exception
+    {
+        WriterFrame f = null;
+        try
+        {
+            f = new WriterFrame(100, 100, 500, 300, true, connection.getComponentContext());
+            if (!f.checkUnoFramePosition())
+            {
+                fail("Sizing error.");
+            }
+
+        }
+        finally
+        {
+            if (f != null)
+            {
+                f.dispose();
+            }
+        }
+    }
+
+    /** Test repeated OOoBean.aquireSystemWindow and OOoBean.releaseSystemWindow
+     * calls.
+     */
+    @Test public void test4() throws Exception
+    {
+        WriterFrame f = null;
+        try
+        {
+            f = new WriterFrame(100, 100, 500, 300, false, connection.getComponentContext());
+            OOoBean b = f.getBean();
+            for (int i = 0; i < 100; i++)
+            {
+                b.releaseSystemWindow();
+                b.aquireSystemWindow();
+            }
+            if (!f.checkUnoFramePosition())
+            {
+                fail("Sizing error.");
+            }
+        }
+        finally
+        {
+            if (f != null)
+            {
+                f.dispose();
+            }
+            if (!isWindows())
+            {
+                Thread.sleep(10000);
+            }
+        }
+    }
+
+    /** Adding and removing the bean to a Java frame multiple times.
+     * Test painting and sizing.
+     */
+    @Test public void test5() throws Exception
+    {
+        WriterFrame f = null;
+        try
+        {
+            f = new WriterFrame(100, 100, 500, 400, false, connection.getComponentContext());
+            f.goToStart();
+            f.pageDown();
+            Thread.sleep(1000);
+
+            ScreenComparer capturer = new ScreenComparer(100,100,500,400);
+            capturer.grabOne();
+            for (int i = 0; i < 100; i++)
+            {
+                f.removeOOoBean();
+                f.addOOoBean();
+            }
+
+            f.goToStart();
+            f.pageDown();
+            Thread.sleep(getSleepTime(200));
+            capturer.grabTwo();
+
+            if (!capturer.compare())
+            {
+                fail("Painting error: adding and removing OOoBean " +
+                       "repeatedly to java.lang.Frame.");
+                capturer.writeImages();
+            }
+
+            if (!f.checkUnoFramePosition())
+            {
+                fail("Sizing error.");
+            }
+
+        }
+        finally
+        {
+            if (f != null)
+            {
+                f.dispose();
+            }
+            if (!isWindows())
+            {
+                Thread.sleep(10000);
+            }
+        }
+    }
+
+
+    /** Test focus  (i49454). After repeatedly adding and removing the bean to a window
+     * it should still be possible to enter text in the window. This does not
+     * work all the time on Windows. This is probably a timing problem. When using
+     * Thread.sleep (position #1) then it should work.
+     */
+    @Test public void test6() throws Exception
+    {
+        for (int j = 0; j < 10; j++)
+        {
+            final OOoBean bean = new OOoBean(new PrivateLocalOfficeConnection(connection.getComponentContext()));
+            java.awt.Frame frame = null;
+            bean.setOOoCallTimeOut(10000);
+            try {
+                frame = new java.awt.Frame("OpenOffice.org Demo");
+                frame.add(bean, BorderLayout.CENTER);
+                frame.pack();
+                frame.setSize(600,300);
+                frame.show();
+                bean.loadFromURL("private:factory/swriter", null);
+                // #1
+                Thread.sleep(1000);
+
+                StringBuffer buf = new StringBuffer(1000);
+                for (int i = 0; i < 1; i++)
+                {
+                    bean.releaseSystemWindow();
+                    frame.remove(bean);
+                    frame.add(bean, BorderLayout.CENTER);
+                    bean.aquireSystemWindow();
+                }
+
+                if (!isWindows())
+                {
+                    Thread.sleep(5000);
+                }
+
+                Robot roby = new Robot();
+                roby.keyPress(KeyEvent.VK_H);
+                roby.keyRelease(KeyEvent.VK_H);
+                buf.append("h");
+
+                String s = getText(bean);
+                if ( ! s.equals(buf.toString()))
+                {
+                    fail("Focus error: After removing and adding the bean, the" +
+                           "office window does not receive keyboard input.\n" +
+                           "Try typing in the window, you've got 30s!!! This " +
+                           "test may not work with Linux/Solaris");
+                    Thread.sleep(30000);
+                    break;
+                }
+                else
+                {
+                    Thread.sleep(2000);
+                }
+
+            } finally {
+                bean.stopOOoConnection();
+                frame.dispose();
+            }
+        }
+    }
+
+    /** Tests focus problem just like test6, but the implementation is a little
+     * different. The bean is added and removed from within the event dispatch
+     * thread. Using Thread.sleep at various points (#1, #2, #3) seems to workaround
+     * the problem.
+     */
+    @Test public void test6a() throws Exception
+    {
+        for (int j = 0; j < 50; j++)
+        {
+            final OOoBean bean = new OOoBean(new PrivateLocalOfficeConnection(connection.getComponentContext()));
+            final java.awt.Frame frame = new Frame("Openoffice.org");
+            bean.setOOoCallTimeOut(10000);
+
+            try {
+                frame.add(bean, BorderLayout.CENTER);
+                frame.pack();
+                frame.setSize(600,400);
+                frame.show();
+                bean.loadFromURL("private:factory/swriter", null);
+                frame.validate();
+                // #1
+                Thread.sleep(1000);
+                StringBuffer buf = new StringBuffer(1000);
+                int i = 0;
+
+                for (; i < 1; i++)
+                {
+                EventQueue.invokeAndWait( new Runnable() {
+                        public void run() {
+                            try {
+
+                            bean.releaseSystemWindow();
+                            frame.remove(bean);
+                            frame.validate();
+
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+
+                            }
+                        });
+                // #2
+                Thread.sleep(1000);
+                EventQueue.invokeAndWait( new Runnable() {
+                        public void run() {
+                            try {
+
+                            frame.add(bean, BorderLayout.CENTER);
+                            bean.aquireSystemWindow();
+                            frame.validate();
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                            }
+                        });
+
+                // #3
+                Thread.sleep(1000);
+                }
+
+                if (!isWindows())
+                {
+                    Thread.sleep(5000);
+                }
+
+                Robot roby = new Robot();
+                roby.mouseMove(300, 200);
+                roby.waitForIdle();
+                roby.mousePress(InputEvent.BUTTON1_MASK);
+                roby.waitForIdle();
+                roby.mouseRelease(InputEvent.BUTTON1_MASK);
+                roby.waitForIdle();
+                roby.keyPress(KeyEvent.VK_H);
+                roby.waitForIdle();
+                roby.keyRelease(KeyEvent.VK_H);
+                roby.waitForIdle();
+
+                buf.append('h');
+                Thread.sleep(1000);
+                String s = getText(bean);
+                System.out.println(" getText: " + s);
+                if ( ! s.equals(buf.toString()))
+                {
+                    roby.mousePress(InputEvent.BUTTON1_MASK);
+                    roby.waitForIdle();
+                    roby.mouseRelease(InputEvent.BUTTON1_MASK);
+                    roby.waitForIdle();
+                    roby.keyPress(KeyEvent.VK_H);
+                    roby.waitForIdle();
+                    roby.keyRelease(KeyEvent.VK_H);
+                    roby.waitForIdle();
+
+                    String sH = "h";
+                    Thread.sleep(1000);
+                    String s2 = getText(bean);
+
+                    if ( ! sH.equals(s2))
+                    {
+                        fail("Focus error: After removing and adding the bean, the" +
+                               "office window does not receive keyboard input.\n" +
+                               "Try typing in the window, you've got 30s!!! This " +
+                               "test may not work with Linux/Solaris");
+                        System.out.println("j: " + j + "   i: " + i);
+                        Thread.sleep(30000);
+                        break;
+                    }
+                }
+
+            } finally {
+                bean.stopOOoConnection();
+                frame.dispose();
+            }
+        }
+    }
+
+    /** Repeatedly loading a document in one and the same OOoBean instance.
+     */
+    @Test public void test7() throws Exception
+    {
+        WriterFrame f = null;
+        try
+        {
+            f = new WriterFrame(100 ,100, 500 ,400, false, connection.getComponentContext());
+            String text = "OOoBean test.";
+
+            for (int i = 0; i < 10; i++)
+            {
+                f.getBean().clear();
+                f.getBean().loadFromURL("private:factory/swriter", null);
+                f.setText(text);
+                f.goToStart();
+                f.validate();
+
+                if (!text.equals(f.getText()))
+                {
+                    fail("Repeated loading of a document failed.");
+                }
+                Thread.sleep(1000);
+            }
+        }
+        finally
+        {
+            if (f != null)
+            {
+                f.dispose();
+            }
+        }
+    }
+
+    /** Using multiple instances of OOoBean at the same time
+     */
+    @Test public void test8() throws Exception
+    {
+        OOoBean bean1 = new OOoBean(new PrivateLocalOfficeConnection(connection.getComponentContext()));
+        BeanPanel bp1 = new BeanPanel(bean1);
+        OOoBean bean2 = new OOoBean(new PrivateLocalOfficeConnection(connection.getComponentContext()));
+        BeanPanel bp2 = new BeanPanel(bean2);
+        OOoBean bean3 = new OOoBean(new PrivateLocalOfficeConnection(connection.getComponentContext()));
+        BeanPanel bp3 = new BeanPanel(bean3);
+        OOoBean bean4 = new OOoBean(new PrivateLocalOfficeConnection(connection.getComponentContext()));
+        BeanPanel bp4 = new BeanPanel(bean4);
+
+        try
+        {
+            Frame f = new Frame("OOoBean example with several instances");
+            f.setLayout(new GridBagLayout());
+            GridBagConstraints c = new GridBagConstraints();
+            c.fill = GridBagConstraints.HORIZONTAL;
+            c.weightx = 0.5;
+
+            c.insets = new Insets(0, 0, 0, 10);
+            c.gridx = 0;
+            c.gridy = 0;
+            f.add(bp1, c);
+
+            c.gridx = 1;
+            c.insets = new Insets(0, 0, 0, 0);
+            f.add(bp2, c);
+
+            c.gridx = 0;
+            c.gridy = 1;
+            c.insets = new Insets(10, 0, 0, 10);
+            f.add(bp3, c);
+
+            c.gridx = 1;
+            c.gridy = 1;
+            c.insets = new Insets(10, 0, 0, 0);
+            f.add(bp4, c);
+
+            f.pack();
+            f.setBounds(0, 0, 1000, 600);
+            f.setVisible(true);
+            try {
+            bean1.loadFromURL("private:factory/swriter", null);
+            bean2.loadFromURL("private:factory/swriter", null);
+            bean3.loadFromURL("private:factory/swriter", null);
+            bean4.loadFromURL("private:factory/swriter", null);
+            } catch( Exception e)
+            {
+                e.printStackTrace();
+            }
+            f.validate();
+
+            Thread.sleep(10000);
+        }
+        finally
+        {
+            bean1.stopOOoConnection();
+            bean2.stopOOoConnection();
+            bean3.stopOOoConnection();
+            bean4.stopOOoConnection();
+        }
+    }
+
+    private class BeanPanel extends Panel
+    {
+        private BeanPanel(OOoBean b)
+        {
+            setLayout(new BorderLayout());
+            add(b, BorderLayout.CENTER);
+        }
+        @Override
+        public Dimension getPreferredSize()
+        {
+            return new Dimension(200, 200);
+        }
+    }
+
+
+    // setup and close connections
+    @BeforeClass public static void setUpConnection() throws Exception {
+        System.out.println("setUpConnection()");
+        connection.setUp();
+    }
+
+    @AfterClass public static void tearDownConnection()
+        throws InterruptedException, com.sun.star.uno.Exception
+    {
+        System.out.println("tearDownConnection()");
+        connection.tearDown();
+    }
+
+    private static final OfficeConnection connection = new OfficeConnection();
+
+
+}
+
+
diff --git a/bean/qa/complex/bean/ScreenComparer.java b/bean/qa/complex/bean/ScreenComparer.java
new file mode 100644
index 000000000..d7b70a828
--- /dev/null
+++ b/bean/qa/complex/bean/ScreenComparer.java
@@ -0,0 +1,231 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+package complex.bean;
+
+
+import java.io.File;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.awt.image.PixelGrabber;
+import javax.imageio.ImageIO;
+
+
+
+class ScreenComparer
+{
+    private Rectangle m_rect;
+    private BufferedImage m_img1;
+    private BufferedImage m_img2;
+    private BufferedImage m_imgDiff;
+
+    private int m_diffColor;
+    public ScreenComparer(int x, int y, int width, int height)
+    {
+        this(new Rectangle(x, y, width, height));
+    }
+
+    private ScreenComparer(Rectangle location)
+    {
+        m_rect = location;
+        int red = 0xff;
+        int alpha = 0xff;
+        m_diffColor = (alpha << 24);
+        m_diffColor = m_diffColor | (red << 16);
+    }
+
+    public ScreenComparer()
+    {
+        this(new Rectangle(0, 0, 0, 0));
+    }
+
+    public void reset()
+    {
+        m_rect = null;
+        m_img1 = null;
+        m_img2 = null;
+        m_imgDiff = null;
+    }
+
+    public void grabOne() throws Exception
+    {
+        grabOne(m_rect);
+    }
+
+    public void grabOne(Rectangle r) throws Exception
+    {
+        java.awt.Robot robot = new java.awt.Robot();
+        m_img1 = robot.createScreenCapture(r);
+    }
+
+    public void grabTwo() throws Exception
+    {
+        grabTwo(m_rect);
+    }
+
+    public void grabTwo(Rectangle r) throws Exception
+    {
+        java.awt.Robot robot = new java.awt.Robot();
+        m_img2 = robot.createScreenCapture(r);
+    }
+
+    public boolean compare() throws Exception
+    {
+        if (m_img1 == null || m_img2 == null)
+        {
+            throw new Exception("Only one image captured!");
+        }
+        boolean ret = true;
+        int w1 = m_img1.getWidth();
+        int h1 = m_img1.getHeight();
+        int w2 = m_img2.getWidth();
+        int h2 = m_img2.getHeight();
+
+        if (w1 != w2 || h1 != h2)
+        {
+            System.out.println("### 1\n");
+            //Different size. Create an image that holds both images.
+            int w = w1 > w2 ? w1 : w2;
+            int h = h1 > h2 ? h1 : h2;
+            m_imgDiff = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+            for (int y = 0; y < h; y ++)
+            {
+                for (int x = 0; x < w; x++)
+                {
+                    boolean bOutOfRange = false;
+                    int pixel1 = 0;
+                    int pixel2 = 0;
+                    //get the pixel for m_img1
+                    if (x < w1 && y < h1)
+                    {
+                        pixel1 = m_img1.getRGB(x, y);
+                    }
+                    else
+                    {
+                        bOutOfRange = true;
+                    }
+
+                    if (x < w2 && y < h2)
+                    {
+                        pixel2 = m_img2.getRGB(x, y);
+                    }
+                    else
+                    {
+                        bOutOfRange = true;
+                    }
+
+                    if (bOutOfRange || pixel1 != pixel2)
+                    {
+                        m_imgDiff.setRGB(x, y, m_diffColor);
+                    }
+                    else
+                    {
+                        m_imgDiff.setRGB(x, y, pixel1);
+                    }
+
+                }
+            }
+            return false;
+        }
+
+        //Images have same dimension
+        int[] pixels1 = new int[w1 * h1];
+        PixelGrabber pg = new PixelGrabber(
+            m_img1.getSource(), 0, 0, w1, h1, pixels1, 0, w1);
+        pg.grabPixels();
+
+        int[] pixels2 = new int[w2 * h2];
+        PixelGrabber pg2 = new PixelGrabber(
+            m_img2.getSource(), 0, 0, w2, h2, pixels2, 0, w2);
+        pg2.grabPixels();
+
+        m_imgDiff = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_ARGB);
+
+        //First check if the images differ.
+        int lenAr = pixels1.length;
+        int index = 0;
+        for (index = 0; index < lenAr; index++)
+        {
+            if (pixels1[index] != pixels2[index])
+            {
+                break;
+            }
+        }
+
+        //If the images are different, then create the diff image
+        if (index < lenAr)
+        {
+            for (int y = 0; y < h1; y++)
+            {
+                for (int x = 0; x < w1; x++)
+                {
+                    int offset = y * w1 + x;
+                    if (pixels1[offset] != pixels2[offset])
+                    {
+                        ret = ret && false;
+                        m_imgDiff.setRGB(x, y, m_diffColor);
+                    }
+                    else
+                    {
+                        m_imgDiff.setRGB(x, y, pixels1[offset]);
+                    }
+                }
+            }
+        }
+        return ret;
+    }
+
+    /** Writes Images to a location. The
+     *  directory is determined by the java property OOoBean.Images
+     *
+     */
+    public void writeImages() throws Exception
+    {
+        String imgLocation = System.getProperty("OOoBean.Images", "");
+        File file_tmp = File.createTempFile("OOoBean", "", new File(imgLocation));
+        File file1 = new File(file_tmp.getPath()+".png");
+        file_tmp.delete();
+        if (m_img1 != null)
+        {
+            ImageIO.write(m_img1, "png", file1);
+            System.out.println("\nCompared images:");
+            System.out.println("1. " + file1.getPath());
+        }
+        file1= null;
+        file_tmp= null;
+        file_tmp = File.createTempFile("OOoBean", "", new File(imgLocation));
+        file1 = new File(file_tmp.getPath()+".png");
+        file_tmp.delete();
+        if (m_img2 != null)
+        {
+            ImageIO.write(m_img2, "png", file1);
+            System.out.println("2. " + file1.getPath());
+        }
+        file1= null;
+        file_tmp= null;
+        file_tmp = File.createTempFile("OOoBean", "_diff", new File(imgLocation));
+        file1 = new File(file_tmp.getPath()+".png");
+        file_tmp.delete();
+        if (m_imgDiff != null)
+        {
+            ImageIO.write(m_imgDiff, "png", file1);
+            System.out.println("Diff image: " + file1.getPath() + "\n");
+        }
+    }
+
+}
+
diff --git a/bean/qa/complex/bean/WriterFrame.java b/bean/qa/complex/bean/WriterFrame.java
new file mode 100644
index 000000000..eb7e477c7
--- /dev/null
+++ b/bean/qa/complex/bean/WriterFrame.java
@@ -0,0 +1,200 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+package complex.bean;
+
+
+import com.sun.star.uno.XComponentContext;
+import java.awt.Rectangle;
+import java.awt.Insets;
+import java.awt.BorderLayout;
+import com.sun.star.comp.beans.OOoBean;
+import com.sun.star.uno.UnoRuntime;
+
+
+
+class WriterFrame extends java.awt.Frame
+{
+    private com.sun.star.comp.beans.OOoBean m_bean;
+    private static final String m_sDocURL = "private:factory/swriter";
+
+    /**
+      @param loadBeforeVisible
+          the OOoBean is added to the frame before it is displayable. Then the Java Frame does
+          not have a native window peer yet.
+     */
+    public WriterFrame(int x, int y, int width, int height, boolean loadBeforeVisible, XComponentContext _xConn) throws Exception
+    {
+
+        try
+        {
+            if (!loadBeforeVisible)
+            {
+                m_bean = new com.sun.star.comp.beans.OOoBean(new PrivateLocalOfficeConnection(_xConn));
+                add(m_bean, BorderLayout.CENTER);
+                pack();
+                setBounds(x, y, width, height);
+                setVisible(true);
+                m_bean.loadFromURL(m_sDocURL, null);
+                validate();
+            }
+            else
+            {
+                m_bean = new com.sun.star.comp.beans.OOoBean(new PrivateLocalOfficeConnection(_xConn));
+                m_bean.loadFromURL(m_sDocURL, null);
+                add(m_bean, BorderLayout.CENTER);
+                pack();
+                setBounds(x, y, width, height);
+                setVisible(true);
+                m_bean.aquireSystemWindow();
+            }
+        }
+        catch (Exception e)
+        {
+            System.out.println("Exception caught: " + e.getMessage());
+        }
+    }
+
+    public WriterFrame() throws Exception
+    {
+        this(0, 0, 800, 400, false, null);
+    }
+
+    public void setText(String s) throws Exception
+    {
+        com.sun.star.frame.XModel model = m_bean.getDocument();
+        com.sun.star.text.XTextDocument myDoc =
+            UnoRuntime.queryInterface(com.sun.star.text.XTextDocument.class, model);
+        com.sun.star.text.XText xText = myDoc.getText();
+        com.sun.star.text.XTextCursor xTCursor = xText.createTextCursor();
+        //inserting some Text
+        xText.insertString( xTCursor, s, false );
+    }
+
+    public String getText() throws Exception
+    {
+        com.sun.star.frame.XModel model = m_bean.getDocument();
+        com.sun.star.text.XTextDocument myDoc =
+            UnoRuntime.queryInterface(com.sun.star.text.XTextDocument.class, model);
+        com.sun.star.text.XText xText = myDoc.getText();
+        return xText.getString();
+    }
+
+    @Override
+    public void dispose() {
+        m_bean.stopOOoConnection();
+        setVisible(false);
+        super.dispose();
+    }
+
+    OOoBean getBean()
+    {
+        return m_bean;
+    }
+
+    /** Makes sure the document is displayed at the beginning.
+     * This is important for comparing screenshots.
+     */
+    public void goToStart() throws Exception
+    {
+        com.sun.star.frame.XModel xModel = m_bean.getDocument();
+        com.sun.star.frame.XController xController = xModel.getCurrentController();
+
+        com.sun.star.text.XTextViewCursorSupplier xVCSupplier =
+            UnoRuntime.queryInterface(com.sun.star.text.XTextViewCursorSupplier.class, xController);
+
+        com.sun.star.text.XTextViewCursor xTViewCursor = xVCSupplier.getViewCursor ( );
+        xTViewCursor.gotoStart(false);
+    }
+
+
+    public void pageDown() throws Exception
+    {
+        com.sun.star.frame.XModel xModel = m_bean.getDocument();
+        com.sun.star.frame.XController xController = xModel.getCurrentController();
+
+        com.sun.star.text.XTextViewCursorSupplier xVCSupplier =
+            UnoRuntime.queryInterface(com.sun.star.text.XTextViewCursorSupplier.class, xController);
+        com.sun.star.text.XTextViewCursor xTViewCursor = xVCSupplier.getViewCursor ( );
+        com.sun.star.view.XScreenCursor xScreenCursor =
+            UnoRuntime.queryInterface(com.sun.star.view.XScreenCursor.class, xTViewCursor);
+        xScreenCursor.screenDown();
+    }
+
+    public Rectangle getClientArea()
+    {
+
+        Insets i = getInsets();
+        Rectangle r = getBounds();
+        Rectangle rc = new Rectangle(r.x + i.left, r.y + i.top,
+                                     r.width - i.left - i.right,
+                                     r.height - i.top - i.bottom);
+        return rc;
+    }
+
+    private Rectangle getUnoFramePosition() throws Exception
+    {
+        com.sun.star.awt.XWindow win = m_bean.getFrame().getContainerWindow();
+        com.sun.star.awt.Rectangle rect = win.getPosSize();
+        return new Rectangle(rect.X, rect.Y, rect.Width, rect.Height);
+    }
+
+    /** After resizing the Java frame, the UNO window shall be resized
+     * as well, which is checked by this method.
+     */
+    public boolean checkUnoFramePosition() throws Exception
+    {
+        Rectangle client = getClientArea();
+        Rectangle unoWin = getUnoFramePosition();
+
+        if (client.x != unoWin.x
+            || client.y != unoWin.y
+            || client.width != unoWin.width
+            || client.height != unoWin.height)
+        {
+            System.out.println("\nPosition of client are of Java frame does not match the position" +
+                               "of the UNO window. These are the values of Java frame, followed by" +
+                               "the UNO window: ");
+            System.out.println(client);
+            System.out.println(unoWin);
+            System.out.println("");
+            return false;
+        }
+
+        return true;
+    }
+
+    public void removeOOoBean() throws Exception
+    {
+        //OOoBean.releaseSystemWindow need not be called because
+        //LocalOfficeWindow overrides removeNotify.
+        //However because of bt4745222 which was fixed in 1.4.2_04,
+        //this is very very slow. The workaround is use releaseSystemWindow
+        //beforehand.
+        m_bean.releaseSystemWindow();
+        remove(m_bean);
+    }
+
+    public void addOOoBean() throws Exception
+    {
+        add(m_bean, BorderLayout.CENTER);
+        m_bean.aquireSystemWindow();
+        validate();
+    }
+
+}
+