From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- bean/qa/complex/bean/OOoBeanTest.java | 684 +++++++++++++++++++++++++++++++ bean/qa/complex/bean/ScreenComparer.java | 231 +++++++++++ bean/qa/complex/bean/WriterFrame.java | 200 +++++++++ 3 files changed, 1115 insertions(+) create mode 100644 bean/qa/complex/bean/OOoBeanTest.java create mode 100644 bean/qa/complex/bean/ScreenComparer.java create mode 100644 bean/qa/complex/bean/WriterFrame.java (limited to 'bean/qa/complex') 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(); + } + +} + -- cgit v1.2.3