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

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

19 files changed, 3753 insertions, 0 deletions

diff --git a/bean/com/sun/star/comp/beans/CallWatchThread.java b/bean/com/sun/star/comp/beans/CallWatchThread.java
new file mode 100644
index 000000000..f03278b6b
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/CallWatchThread.java
@@ -0,0 +1,119 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+
+/** Helper class to watch calls into OOo with a timeout.
+ */
+// Do not add the thread instances to a threadgroup. When testing the bean in
+// an applet it turned out the ThreadGroup was in an inconsistent state
+// after navigating off the site that contains the applet and back to it.
+// That was tested with a Sun JRE 1.4.2_06
+public class CallWatchThread extends Thread
+{
+    private static boolean DEBUG = false;
+
+    private Thread aWatchedThread;
+    private String aTag;
+    private boolean bAlive;
+    private long nTimeout;
+
+    public CallWatchThread(long nTimeout)
+    {
+        this(nTimeout, "CallWatchThread");
+    }
+
+    public CallWatchThread( long nTimeout, String aTag )
+    {
+        super(aTag);
+        this.aWatchedThread = Thread.currentThread();
+        this.nTimeout = nTimeout;
+
+        this.aTag = aTag;
+        setDaemon( true );
+        dbgPrint( "CallWatchThread(" + this + ").start(" + aTag + ")" );
+        start();
+    }
+
+    public void cancel()
+        throws InterruptedException
+    {
+        dbgPrint( "CallWatchThread(" + this + ".cancel(" + aTag + ")" );
+        if ( aWatchedThread != null && aWatchedThread != Thread.currentThread() )
+            throw new RuntimeException( "wrong thread" );
+        aWatchedThread = null;
+        if ( interrupted() )
+            throw new InterruptedException();
+    }
+
+    public synchronized void restart()
+        throws InterruptedException
+    {
+        dbgPrint( "CallWatchThread(" + this + ".restart(" + aTag + ")" );
+        if ( aWatchedThread != null && aWatchedThread != Thread.currentThread() )
+            throw new RuntimeException( "wrong thread" );
+        bAlive = true;
+        if ( interrupted() )
+            throw new InterruptedException();
+        notify();
+    }
+
+    @Override
+    public void run()
+    {
+        dbgPrint( "CallWatchThread(" + this + ".run(" + aTag + ") ***** STARTED *****" );
+        long n = 0;
+        synchronized(this)
+        {
+            while ( aWatchedThread != null )
+            {
+                dbgPrint( "CallWatchThread(" + this + ").run(" + aTag + ") running #" + ++n );
+                bAlive = false;
+                try
+                {
+                    wait( nTimeout );
+                }
+                catch ( InterruptedException aExc )
+                {
+                    bAlive = false;
+                }
+
+                // watched thread seems to be dead (not answering)?
+                if ( !bAlive && aWatchedThread != null )
+                {
+                    dbgPrint( "CallWatchThread(" + this + ").run(" + aTag + ") interrupting" );
+                    aWatchedThread.interrupt();
+                    aWatchedThread = null;
+                }
+            }
+        }
+
+        dbgPrint( "CallWatchThread(" + this + ").run(" + aTag + ") terminated" );
+    }
+
+    private void dbgPrint( String aMessage )
+    {
+        if (DEBUG)
+            System.err.println( "OOoBean: " + aMessage );
+    }
+}
+
+
+
+
diff --git a/bean/com/sun/star/comp/beans/ContainerFactory.java b/bean/com/sun/star/comp/beans/ContainerFactory.java
new file mode 100644
index 000000000..d7ebfba38
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/ContainerFactory.java
@@ -0,0 +1,35 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import java.awt.Container;
+
+/**
+ * This interface represents an AWT container factory.
+ */
+@Deprecated
+public interface ContainerFactory
+{
+    /**
+     * Creates an AWT container.
+     *
+     * @return An AWT container.
+     */
+    Container createContainer();
+}
diff --git a/bean/com/sun/star/comp/beans/Controller.java b/bean/com/sun/star/comp/beans/Controller.java
new file mode 100644
index 000000000..91f64db87
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/Controller.java
@@ -0,0 +1,100 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.uno.UnoRuntime;
+
+/** Wrapper class for a com.sun.star.frame.XController.
+ *
+ * @since OOo 2.0.0
+ */
+public class Controller
+    extends Wrapper
+    implements
+        com.sun.star.frame.XController
+{
+    private final com.sun.star.frame.XController xController;
+    private final com.sun.star.frame.XDispatchProvider xDispatchProvider;
+
+    Controller( com.sun.star.frame.XController xController )
+    {
+        super( xController );
+        this.xController = xController;
+        xDispatchProvider = UnoRuntime.queryInterface( com.sun.star.frame.XDispatchProvider.class,
+            xController );
+    }
+
+
+    // com.sun.star.frame.XController
+
+
+    public void attachFrame( /*IN*/ com.sun.star.frame.XFrame xFrame )
+    {
+        xController.attachFrame( xFrame );
+    }
+
+    public boolean attachModel( /*IN*/ com.sun.star.frame.XModel xModel )
+    {
+        return xController.attachModel( xModel );
+    }
+
+    public boolean suspend( /*IN*/boolean bSuspend )
+    {
+        return xController.suspend( bSuspend );
+    }
+
+    public java.lang.Object getViewData(  )
+    {
+        return xController.getViewData();
+    }
+
+    public void restoreViewData( /*IN*/java.lang.Object aData )
+    {
+        xController.restoreViewData( aData );
+    }
+
+    public com.sun.star.frame.XModel getModel(  )
+    {
+        return xController.getModel();
+    }
+
+    public com.sun.star.frame.XFrame getFrame(  )
+    {
+        return xController.getFrame();
+    }
+
+
+    // com.sun.star.frame.XDispatchProvider
+
+
+    public com.sun.star.frame.XDispatch queryDispatch(
+            /*IN*/ com.sun.star.util.URL aURL,
+            /*IN*/ String aTargetFrameName,
+            /*IN*/ int nSearchFlags )
+    {
+        return xDispatchProvider.queryDispatch( aURL, aTargetFrameName, nSearchFlags );
+    }
+
+    public com.sun.star.frame.XDispatch[] queryDispatches(
+            /*IN*/ com.sun.star.frame.DispatchDescriptor[] aRequests )
+    {
+        return xDispatchProvider.queryDispatches( aRequests );
+    }
+}
+
diff --git a/bean/com/sun/star/comp/beans/Frame.java b/bean/com/sun/star/comp/beans/Frame.java
new file mode 100644
index 000000000..fbf9ca97e
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/Frame.java
@@ -0,0 +1,171 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.uno.UnoRuntime;
+
+/** Wrapper class for a com.sun.star.frame.XFrame.
+ *
+ * @since OOo 2.0.0
+ */
+public class Frame
+    extends Wrapper
+    implements
+        com.sun.star.frame.XFrame,
+        com.sun.star.frame.XDispatchProvider,
+        com.sun.star.frame.XDispatchProviderInterception
+{
+    private final com.sun.star.frame.XFrame xFrame;
+    private final com.sun.star.frame.XDispatchProvider xDispatchProvider;
+    private final com.sun.star.frame.XDispatchProviderInterception xDispatchProviderInterception;
+
+    public Frame( com.sun.star.frame.XFrame xFrame )
+    {
+        super( xFrame );
+        this.xFrame = xFrame;
+        xDispatchProvider = UnoRuntime.queryInterface( com.sun.star.frame.XDispatchProvider.class,
+            xFrame );
+        xDispatchProviderInterception = UnoRuntime.queryInterface( com.sun.star.frame.XDispatchProviderInterception.class,
+            xFrame );
+    }
+
+
+    // com.sun.star.frame.XFrame
+
+
+    public void initialize( /*IN*/ com.sun.star.awt.XWindow xWindow )
+    {
+        xFrame.initialize( xWindow );
+    }
+
+    public com.sun.star.awt.XWindow getContainerWindow(  )
+    {
+        return xFrame.getContainerWindow();
+    }
+
+    public void setCreator( /*IN*/ com.sun.star.frame.XFramesSupplier xCreator )
+    {
+        xFrame.setCreator( xCreator );
+    }
+
+    public com.sun.star.frame.XFramesSupplier getCreator(  )
+    {
+        return xFrame.getCreator();
+    }
+
+    public String getName(  )
+    {
+        return xFrame.getName();
+    }
+
+    public void setName( /*IN*/ String aName )
+    {
+        xFrame.setName( aName );
+    }
+
+    public com.sun.star.frame.XFrame findFrame( /*IN*/ String aTargetFrameName, /*IN*/ int nSearchFlags )
+    {
+        return xFrame.findFrame( aTargetFrameName, nSearchFlags );
+    }
+
+    public boolean isTop(  )
+    {
+        return xFrame.isTop();
+    }
+
+    public void activate(  )
+    {
+        xFrame.activate();
+    }
+
+    public void deactivate(  )
+    {
+        xFrame.deactivate();
+    }
+
+    public boolean isActive(  )
+    {
+        return xFrame.isActive();
+    }
+
+    public boolean setComponent( /*IN*/ com.sun.star.awt.XWindow xComponentWindow, /*IN*/ com.sun.star.frame.XController xController )
+    {
+        return xFrame.setComponent( xComponentWindow, xController );
+    }
+
+    public com.sun.star.awt.XWindow getComponentWindow(  )
+    {
+        return xFrame.getComponentWindow();
+    }
+
+    public com.sun.star.frame.XController getController(  )
+    {
+        return xFrame.getController();
+    }
+
+    public void contextChanged(  )
+    {
+        xFrame.contextChanged();
+    }
+
+    public void addFrameActionListener( /*IN*/ com.sun.star.frame.XFrameActionListener xListener )
+    {
+        xFrame.addFrameActionListener( xListener );
+    }
+
+    public void removeFrameActionListener( /*IN*/ com.sun.star.frame.XFrameActionListener xListener )
+    {
+        xFrame.removeFrameActionListener( xListener );
+    }
+
+
+    // com.sun.star.frame.XDispatchProvider
+
+
+    public com.sun.star.frame.XDispatch queryDispatch(
+            /*IN*/ com.sun.star.util.URL aURL,
+            /*IN*/ String aTargetFrameName,
+            /*IN*/ int nSearchFlags )
+    {
+        return xDispatchProvider.queryDispatch( aURL, aTargetFrameName, nSearchFlags );
+    }
+
+    public com.sun.star.frame.XDispatch[] queryDispatches(
+            /*IN*/ com.sun.star.frame.DispatchDescriptor[] aRequests )
+    {
+        return xDispatchProvider.queryDispatches( aRequests );
+    }
+
+
+    // com.sun.star.frame.XDispatchProviderInterception
+
+
+    public void registerDispatchProviderInterceptor(
+            /*IN*/ com.sun.star.frame.XDispatchProviderInterceptor xInterceptor )
+    {
+        xDispatchProviderInterception.registerDispatchProviderInterceptor( xInterceptor );
+    }
+
+    public void releaseDispatchProviderInterceptor(
+            /*IN*/ com.sun.star.frame.XDispatchProviderInterceptor xInterceptor )
+    {
+        xDispatchProviderInterception.releaseDispatchProviderInterceptor( xInterceptor );
+    }
+}
+
diff --git a/bean/com/sun/star/comp/beans/HasConnectionException.java b/bean/com/sun/star/comp/beans/HasConnectionException.java
new file mode 100644
index 000000000..289465949
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/HasConnectionException.java
@@ -0,0 +1,31 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+/** This exception is thrown when a method is called which
+    is only defined for not already having an established
+    connection.
+
+    @since OOo 2.0.0
+ */
+public class HasConnectionException extends Exception
+{
+}
+
+
diff --git a/bean/com/sun/star/comp/beans/InvalidArgumentException.java b/bean/com/sun/star/comp/beans/InvalidArgumentException.java
new file mode 100644
index 000000000..2c15f2db1
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/InvalidArgumentException.java
@@ -0,0 +1,28 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+/** indicates an invalid argument in a function call.
+ */
+@Deprecated
+public class InvalidArgumentException extends Exception
+{
+}
+
+
diff --git a/bean/com/sun/star/comp/beans/JavaWindowPeerFake.java b/bean/com/sun/star/comp/beans/JavaWindowPeerFake.java
new file mode 100644
index 000000000..d2d1d351d
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/JavaWindowPeerFake.java
@@ -0,0 +1,113 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.uno.*;
+import com.sun.star.awt.*;
+
+/** <p>Class to pass the system window handle to the OpenOffice.org toolkit.</p>
+ *
+ * @since OOo 2.0.0
+ */
+class JavaWindowPeerFake
+    implements XSystemDependentWindowPeer, XWindowPeer
+{
+    protected int localSystemType;
+    protected Any wrappedHandle;
+
+    /** Create the faked window peer.
+     * @param _hWindow the system handle to the window.
+     * @param _systemType specifies the system type.
+     */
+    public JavaWindowPeerFake(Any _hWindow, int _systemType)
+    {
+        localSystemType = _systemType;
+        wrappedHandle = _hWindow;
+    }
+
+    /** <p>Implementation of XSystemDependentWindowPeer (that's all we really need)</p>
+     *  This method is called back from the OpenOffice.org toolkit to retrieve the system data.
+     */
+    public Object getWindowHandle(/*IN*/ byte[] ProcessId, /*IN*/ short SystemType)
+        throws com.sun.star.uno.RuntimeException
+    {
+        if (SystemType == localSystemType) {
+            return wrappedHandle;
+        }
+        else return null;
+    }
+
+    /** not really needed.
+     */
+    public XToolkit getToolkit()
+        throws com.sun.star.uno.RuntimeException
+    {
+        return null;
+    }
+
+    /** not really needed.
+     */
+    public void setPointer(/*IN*/ XPointer Pointer)
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+
+    /** not really needed.
+     */
+    public void setBackground(/*IN*/ int Color)
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+
+    /** not really needed.
+     */
+    public void invalidate(/*IN*/ short Flags)
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+
+    /** not really needed.
+     */
+    public void invalidateRect(/*IN*/ com.sun.star.awt.Rectangle Rect, /*IN*/ short Flags)
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+
+    /** not really needed.
+     */
+    public void dispose()
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+
+    /** not really needed.
+     */
+    public void addEventListener(/*IN*/ com.sun.star.lang.XEventListener xListener)
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+
+    /** not really needed.
+     */
+    public void removeEventListener(/*IN*/ com.sun.star.lang.XEventListener aListener)
+        throws com.sun.star.uno.RuntimeException
+    {
+    }
+}
+
diff --git a/bean/com/sun/star/comp/beans/LocalOfficeConnection.java b/bean/com/sun/star/comp/beans/LocalOfficeConnection.java
new file mode 100644
index 000000000..7872d4934
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/LocalOfficeConnection.java
@@ -0,0 +1,768 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import java.awt.Container;
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.bridge.XBridge;
+import com.sun.star.bridge.XBridgeFactory;
+import com.sun.star.connection.XConnection;
+import com.sun.star.connection.XConnector;
+import com.sun.star.lang.XComponent;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.lib.uno.helper.UnoUrl;
+import com.sun.star.lib.util.NativeLibraryLoader;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+
+/**
+ * This class represents a connection to the local office application.
+ *
+ * @since OOo 2.0.0
+ */
+public class LocalOfficeConnection
+    implements OfficeConnection
+{
+    public static final String      OFFICE_APP_NAME     = "soffice";
+    public static final String       OFFICE_LIB_NAME     = "officebean";
+    public static final String      OFFICE_ID_SUFFIX    = "_Office";
+
+    private Process                 mProcess;
+    private XComponentContext       mContext;
+    private XBridge mBridge;
+
+    private String                  mURL;
+    private String                  mConnType;
+    private String                  mPipe;
+    private String                  mPort;
+    private String                  mProtocol;
+    private String                  mInitialObject;
+
+    private final List<XEventListener> mComponents = new ArrayList<XEventListener>();
+
+    private static final AtomicLong m_nBridgeCounter = new AtomicLong(0);
+
+    static
+    {
+        // preload shared libraries which import lips are linked to officebean
+        if ( System.getProperty( "os.name" ).startsWith( "Windows" ) )
+        {
+            try
+            {
+                NativeLibraryLoader.loadLibrary(LocalOfficeConnection.class.getClassLoader(), "msvcr70");
+            }
+            catch (Throwable e)
+            {
+                // loading twice would fail
+                System.err.println( "cannot find msvcr70" );
+            }
+
+            try
+            {
+                NativeLibraryLoader.loadLibrary(LocalOfficeConnection.class.getClassLoader(), "msvcr71");
+            }
+            catch (Throwable e)
+            {
+                // loading twice would fail
+                System.err.println( "cannot find msvcr71" );
+            }
+
+            try
+            {
+                NativeLibraryLoader.loadLibrary(LocalOfficeConnection.class.getClassLoader(), "jawt");
+            }
+            catch (Throwable e)
+            {
+                // loading twice would fail
+                System.err.println("cannot find jawt:");
+                e.printStackTrace();
+            }
+        }
+
+        // load shared library for JNI code
+        NativeLibraryLoader.loadLibrary( LocalOfficeConnection.class.getClassLoader(), "officebean" );
+    }
+
+
+    /**
+     * Constructor.
+     * Sets up paths to the office application and native libraries if
+     * values are available in <code>OFFICE_PROP_FILE</code> in the user
+     * home directory.<br>
+     * "com.sun.star.beans.path" - the office application directory;<br>
+     * "com.sun.star.beans.libpath" - native libraries directory.
+     */
+    public LocalOfficeConnection()
+    {
+        // init member vars
+        try
+        {
+            setUnoUrl( "uno:pipe,name=" + getPipeName() + ";urp;StarOffice.ServiceManager" );
+        }
+        catch ( java.net.MalformedURLException e )
+        {
+            throw new com.sun.star.uno.RuntimeException(e);
+        }
+        catch ( UnsupportedEncodingException e)
+        {
+            throw new com.sun.star.uno.RuntimeException(e);
+        }
+    }
+
+        /**
+         * protected Constructor
+         * Initialise a LocalOfficeConnection with an already running office.
+         * This C'Tor is only used in complex tests at the moment.
+         * @param xContext
+         */
+        protected LocalOfficeConnection(com.sun.star.uno.XComponentContext xContext)
+        {
+            this.mContext = xContext;
+        }
+
+        /**
+     * Sets a connection URL.
+     * This implementation accepts a UNO URL with following format:<br>
+     * <pre>
+     * url    := uno:localoffice[,&lt;params&gt;];urp;StarOffice.ServiceManager
+     * params := &lt;path&gt;[,&lt;pipe&gt;]
+     * path   := path=&lt;pathv&gt;
+     * pipe   := pipe=&lt;pipev&gt;
+     * pathv  := platform_specific_path_to_the_local_office_distribution
+     * pipev  := local_office_connection_pipe_name
+     * </pre>
+     *
+     * @param url This is UNO URL which describes the type of a connection.
+     */
+    public void setUnoUrl(String url)
+        throws java.net.MalformedURLException
+    {
+        mURL    = null;
+
+        String prefix = "uno:localoffice";
+        if ( url.startsWith(prefix) )
+            parseUnoUrlWithOfficePath( url, prefix );
+        else
+        {
+            try
+            {
+                UnoUrl aURL = UnoUrl.parseUnoUrl( url );
+                mConnType = aURL.getConnection();
+                mPipe = aURL.getConnectionParameters().get( "pipe" );
+                mPort = aURL.getConnectionParameters().get( "port" );
+                mProtocol = aURL.getProtocol();
+                mInitialObject = aURL.getRootOid();
+            }
+            catch ( com.sun.star.lang.IllegalArgumentException ex1 )
+            {
+                java.net.MalformedURLException ex2 = new java.net.MalformedURLException(
+                    "Invalid UNO connection URL.");
+                ex2.initCause(ex1);
+                throw ex2;
+            }
+        }
+        mURL    = url;
+    }
+
+    /**
+     * Sets an AWT container factory.
+     *
+     * @param containerFactory This is an application provided AWT container
+     *  factory.
+     */
+    @Deprecated
+    public void setContainerFactory(ContainerFactory containerFactory)
+    {
+    }
+
+    /**
+     * Retrieves the UNO component context.
+     * Establishes a connection if necessary and initialises the
+     * UNO service manager if it has not already been initialised.
+     * This method can return <code>null</code> if it fails to connect
+     * to the office application.
+     *
+     * @return The office UNO component context.
+     */
+    synchronized public XComponentContext getComponentContext()
+    {
+        if ( mContext == null )
+            mContext = connect();
+        return mContext;
+    }
+
+    /**
+     * Creates an office java.awt.Canvas based window.
+     *
+     * @param container This is an AWT container.
+     * @return The office window instance.
+     */
+    @Deprecated
+    public OfficeWindow createOfficeWindow(Container container)
+    {
+        return new LocalOfficeWindow(this);
+    }
+
+    /**
+     * Closes the connection.
+     */
+    public void dispose()
+    {
+        Iterator<XEventListener> itr = mComponents.iterator();
+        while (itr.hasNext()) {
+            // ignore runtime exceptions in dispose
+            try { itr.next().disposing(null); }
+            catch ( RuntimeException aExc ) {}
+        }
+        mComponents.clear();
+
+        // Terminate the bridge. It turned out that this is necessary for the bean
+        // to work properly when displayed in an applet within Internet Explorer.
+        // When navigating off the page which is showing  the applet and then going
+        // back to it, then the Java remote bridge is damaged. That is the Java threads
+        // do not work properly anymore. Therefore when Applet.stop is called the connection
+        // to the office including the bridge needs to be terminated.
+        if (mBridge != null)
+        {
+            XComponent comp = UnoRuntime.queryInterface(
+                    XComponent.class, mBridge);
+            if (comp != null)
+               comp.dispose();
+            else
+                System.err.println("LocalOfficeConnection: could not dispose bridge!");
+
+            mBridge = null;
+        }
+        mContext = null;
+    }
+
+    /**
+     * Adds an event listener to the object.
+     *
+     * @param listener is a listener object.
+     */
+    public void addEventListener(XEventListener listener)
+    {
+        mComponents.add(listener);
+    }
+
+    /**
+     * Removes an event listener from the listener list.
+     *
+     * @param listener is a listener object.
+     */
+    public void removeEventListener(XEventListener listener)
+    {
+        mComponents.remove(listener);
+    }
+
+    /**
+     * Establishes the connection to the office.
+     */
+    private XComponentContext connect()
+    {
+        try
+        {
+            // create default local component context
+            XComponentContext xLocalContext =
+                com.sun.star.comp.helper.Bootstrap.createInitialComponentContext(null);
+
+            // initial serviceManager
+            xLocalContext.getServiceManager();
+
+            // try to connect to soffice
+            Object aInitialObject = null;
+            try
+            {
+                aInitialObject = resolve(xLocalContext, mURL);
+            }
+            catch( com.sun.star.connection.NoConnectException e )
+            {
+                // launch soffice
+                OfficeService aSOffice = new OfficeService();
+                aSOffice.startupService();
+
+                // wait until soffice is started
+                long nGiveUpTimeMillis = System.currentTimeMillis() + 1000L*aSOffice.getStartupTime();
+                while ( aInitialObject == null )
+                {
+                    try
+                    {
+                        Thread.currentThread();
+                        // try to connect to soffice
+                        Thread.sleep( 100 );
+                        aInitialObject = resolve(xLocalContext, mURL);
+                    }
+                    catch( com.sun.star.connection.NoConnectException aEx )
+                    {
+                        // soffice did not start in time
+                        if ( System.currentTimeMillis() > nGiveUpTimeMillis )
+                            throw aEx;
+                    }
+                }
+            }
+
+            // XComponentContext
+            if( null != aInitialObject )
+            {
+                XPropertySet xPropertySet = UnoRuntime.queryInterface( XPropertySet.class, aInitialObject);
+                        Object xContext = xPropertySet.getPropertyValue("DefaultContext");
+                        XComponentContext xComponentContext = UnoRuntime.queryInterface(
+                    XComponentContext.class, xContext);
+                return xComponentContext;
+            }
+        }
+        catch( com.sun.star.connection.NoConnectException e )
+        {
+            System.out.println( "Couldn't connect to remote server" );
+            System.out.println( e.getMessage() );
+        }
+        catch( com.sun.star.connection.ConnectionSetupException e )
+        {
+            System.out.println( "Couldn't access necessary local resource to establish the interprocess connection" );
+            System.out.println( e.getMessage() );
+        }
+        catch( com.sun.star.lang.IllegalArgumentException e )
+        {
+            System.out.println( "uno-url is syntactical illegal ( " + mURL + " )" );
+            System.out.println( e.getMessage() );
+        }
+        catch( com.sun.star.uno.RuntimeException e )
+        {
+            System.out.println( "--- RuntimeException:" );
+            System.out.println( e.getMessage() );
+            e.printStackTrace();
+            System.out.println( "--- end." );
+            throw e;
+        }
+        catch( java.lang.Exception e )
+        {
+            System.out.println( "java.lang.Exception: " );
+            System.out.println( e );
+            e.printStackTrace();
+            System.out.println( "--- end." );
+            throw new com.sun.star.uno.RuntimeException(e);
+        }
+
+        return null;
+    }
+
+
+    // The function is copied and adapted from the UrlResolver.resolve.
+    // We cannot use the URLResolver because we need access to the bridge which has
+    // to be disposed when Applet.stop is called.
+    private Object resolve(XComponentContext xLocalContext, String dcp)
+        throws com.sun.star.connection.NoConnectException,
+            com.sun.star.connection.ConnectionSetupException,
+            com.sun.star.lang.IllegalArgumentException
+    {
+        String conDcp = null;
+        String protDcp = null;
+        String rootOid = null;
+
+        if(dcp.indexOf(';') == -1) { // use old style
+            conDcp = dcp;
+            protDcp = "iiop";
+            rootOid = "classic_uno";
+        }
+        else { // new style
+            int index = dcp.indexOf(':');
+            dcp = dcp.substring(index + 1).trim();
+
+            index = dcp.indexOf(';');
+            conDcp = dcp.substring(0, index).trim();
+            dcp = dcp.substring(index + 1).trim();
+
+            index = dcp.indexOf(';');
+            protDcp = dcp.substring(0, index).trim();
+            dcp = dcp.substring(index + 1).trim();
+
+            rootOid = dcp.trim().trim();
+        }
+
+        Object rootObject = null;
+        XBridgeFactory xBridgeFactory= null;
+
+        XMultiComponentFactory xLocalServiceManager = xLocalContext.getServiceManager();
+        try {
+            xBridgeFactory = UnoRuntime.queryInterface(
+                    XBridgeFactory.class,
+                    xLocalServiceManager.createInstanceWithContext(
+                        "com.sun.star.bridge.BridgeFactory", xLocalContext));
+        } catch (com.sun.star.uno.Exception e) {
+            throw new com.sun.star.uno.RuntimeException(e);
+        }
+        synchronized(this) {
+            if(mBridge == null) {
+                Object connector= null;
+                try {
+                    connector = xLocalServiceManager.createInstanceWithContext(
+                            "com.sun.star.connection.Connector", xLocalContext);
+                } catch (com.sun.star.uno.Exception e) {
+                    throw new com.sun.star.uno.RuntimeException(e);
+                }
+                XConnector connector_xConnector = UnoRuntime.queryInterface(XConnector.class, connector);
+                // connect to the server
+                XConnection xConnection = connector_xConnector.connect(conDcp);
+                // create the bridge name. This should not be necessary if we pass an
+                // empty string as bridge name into createBridge. Then we should always get
+                // a new bridge. This does not work because of (i51323). Therefore we
+                // create unique bridge names for the current process.
+                String sBridgeName = "OOoBean_private_bridge_" + m_nBridgeCounter.getAndIncrement();
+                try {
+                    mBridge = xBridgeFactory.createBridge(sBridgeName, protDcp, xConnection, null);
+                } catch (com.sun.star.bridge.BridgeExistsException e) {
+                    throw new com.sun.star.uno.RuntimeException(e);
+                }
+            }
+            rootObject = mBridge.getInstance(rootOid);
+            return rootObject;
+        }
+    }
+
+
+    /**
+     * Parses a connection URL.
+     * This method accepts a UNO URL with following format:<br>
+     * <pre>
+     * url    := uno:localoffice[,&lt;params&gt;];urp;StarOffice.NamingService
+     * params := &lt;path&gt;[,&lt;pipe&gt;]
+     * path   := path=&lt;pathv&gt;
+     * pipe   := pipe=&lt;pipev&gt;
+     * pathv  := platform_specific_path_to_the_local_office_distribution
+     * pipev  := local_office_connection_pipe_name
+     * </pre>
+     *
+     * <h4>Examples</h4>
+     * <ul>
+     *  <li>"uno:localoffice,pipe=xyz_Office,path=/opt/openoffice11/program;urp;StarOffice.ServiceManager";
+     *  <li>"uno:socket,host=localhost,port=8100;urp;StarOffice.ServiceManager";
+     * </ul>
+     *
+     * @param url This is UNO URL which describes the type of a connection.
+     * @exception java.net.MalformedURLException when inappropriate URL was
+     *  provided.
+     */
+    private void parseUnoUrlWithOfficePath(String url, String prefix)
+        throws java.net.MalformedURLException
+    {
+        // Extract parameters.
+        int idx = url.indexOf(";urp;StarOffice.ServiceManager");
+        if (idx < 0)
+            throw new java.net.MalformedURLException(
+                "Invalid UNO connection URL.");
+        String  params  = url.substring(prefix.length(), idx + 1);
+
+        // Parse parameters.
+        String  name    = null;
+        String  path    = null;
+        String  pipe    = null;
+        char    ch;
+        int     state   = 0;
+        StringBuffer    buffer  = new StringBuffer();
+        for(idx = 0; idx < params.length(); idx += 1) {
+            ch  = params.charAt(idx);
+            switch (state) {
+            case 0: // initial state
+                switch(ch) {
+                case ',':
+                    buffer.delete(0, buffer.length());
+                    state   = 1;
+                    break;
+
+                case ';':
+                    state   = 7;
+                    break;
+
+                default:
+                    buffer.delete(0, buffer.length());
+                    buffer.append(ch);
+                    state   = 1;
+                    break;
+                }
+                break;
+
+            case 1: // parameter name
+                switch(ch) {
+                case ' ':
+                case '=':
+                    name    = buffer.toString();
+                    state   = (ch == ' ')? 2: 3;
+                    break;
+
+                case ',':
+                case ';':
+                    state   = -6;           // error: invalid name
+                    break;
+
+                default:
+                    buffer.append(ch);
+                    break;
+                }
+                break;
+
+            case 2: // equal between the name and the value
+                switch(ch) {
+                case '=':
+                    state   = 3;
+                    break;
+
+                case ' ':
+                    break;
+
+                default:
+                    state   = -1;           // error: missing '='
+                    break;
+                }
+                break;
+
+            case 3: // value leading spaces
+                switch(ch) {
+                case ' ':
+                    break;
+
+                default:
+                    buffer.delete(0, buffer.length());
+                    buffer.append(ch);
+                    state   = 4;
+                    break;
+                }
+                break;
+
+            case 4: // value
+                switch(ch) {
+                case ' ':
+                case ',':
+                case ';':
+                    idx     -= 1;           // put back the last read character
+                    state   = 5;
+                    if (name.equals("path")) {
+                        if (path == null)
+                            path    = buffer.toString();
+                        else
+                            state   = -3;   // error: more than one 'path'
+                    } else if (name.equals("pipe")) {
+                        if (pipe == null)
+                            pipe    = buffer.toString();
+                        else
+                            state   = -4;   // error: more than one 'pipe'
+                    } else
+                        state   = -2;       // error: unknown parameter
+                    buffer.delete(0, buffer.length());
+                    break;
+
+                default:
+                    buffer.append(ch);
+                    break;
+                }
+                break;
+
+            case 5: // a delimiter after the value
+                switch(ch) {
+                case ' ':
+                    break;
+
+                case ',':
+                    state   = 6;
+                    break;
+
+                case ';':
+                    state   = 7;
+                    break;
+
+                default:
+                    state   = -5;           // error: ' ' inside the value
+                    break;
+                }
+                break;
+
+            case 6: // leading spaces before next parameter name
+                switch(ch) {
+                case ' ':
+                    break;
+
+                default:
+                    buffer.delete(0, buffer.length());
+                    buffer.append(ch);
+                    state   = 1;
+                    break;
+                }
+                break;
+
+            default:
+                throw new java.net.MalformedURLException(
+                    "Invalid UNO connection URL.");
+            }
+        }
+        if (state != 7)
+            throw new java.net.MalformedURLException(
+                "Invalid UNO connection URL.");
+
+        // Set up the connection parameters.
+        if (pipe != null)
+            mPipe = pipe;
+    }
+
+    /** creates a unique pipe name.
+    */
+    private static String getPipeName() throws UnsupportedEncodingException
+    {
+        // turn user name into a URL and file system safe name (% chars will not work)
+        String aPipeName = System.getProperty("user.name") + OFFICE_ID_SUFFIX;
+        aPipeName = aPipeName.replace( "_", "%B7" );
+        return java.net.URLEncoder.encode( aPipeName, "UTF-8" ).replace( "+", "%20" ).replace( "%", "_" );
+    }
+
+    /**
+     * @para This is an implementation of the native office service.
+     */
+    private class OfficeService
+        implements NativeService
+    {
+        /**
+         * Retrieve the office service identifier.
+         *
+         * @return The identifier of the office service.
+         */
+        public String getIdentifier()
+        {
+            String identifier = null;
+            try
+            {
+                identifier = ( mPipe == null) ? getPipeName() : mPipe;
+            }
+            catch (UnsupportedEncodingException e)
+            {
+                throw new com.sun.star.uno.RuntimeException(e);
+            }
+            return identifier;
+        }
+
+        /**
+         * Starts the office process.
+         */
+        public void startupService()
+            throws java.io.IOException
+        {
+            int nSizeCmdArray = 4;
+            String sOption = null;
+            // examine if user specified command-line options in system properties.
+            // We may offer later a more sophisticated way of providing options if
+            // the need arises. Currently this is intended to ease the pain during
+            // development  with pre-release builds of LibO where one wants to start
+            // LibO with the --norestore options. The value of the property is simple
+            // passed on to the Runtime.exec call.
+            try {
+                sOption = System.getProperty("com.sun.star.officebean.Options");
+                if (sOption != null)
+                    nSizeCmdArray ++;
+            } catch (java.lang.SecurityException e)
+            {
+                e.printStackTrace();
+            }
+            // create call with arguments
+            String[] cmdArray = new String[nSizeCmdArray];
+
+            // read UNO_PATH environment variable to get path to soffice binary
+            String unoPath = System.getenv("UNO_PATH");
+            if (unoPath == null)
+                throw new java.io.IOException( "UNO_PATH environment variable is not set (required system path to the office program directory)" );
+
+            cmdArray[0] = new File(unoPath, OFFICE_APP_NAME).getPath();
+            cmdArray[1] = "--nologo";
+            cmdArray[2] = "--nodefault";
+            if ( mConnType.equals( "pipe" ) )
+                cmdArray[3] = "--accept=pipe,name=" + getIdentifier() + ";" +
+                          mProtocol + ";" + mInitialObject;
+            else if ( mConnType.equals( "socket" ) )
+                cmdArray[3] = "--accept=socket,port=" + mPort + ";urp";
+            else
+                throw new java.io.IOException( "not connection specified" );
+
+            if (sOption != null)
+                cmdArray[4] = sOption;
+
+            // start process
+            mProcess = Runtime.getRuntime().exec(cmdArray);
+            if ( mProcess == null )
+                throw new com.sun.star.uno.RuntimeException( "cannot start soffice: " + Arrays.toString(cmdArray) );
+            new StreamProcessor(mProcess.getInputStream(), System.out);
+            new StreamProcessor(mProcess.getErrorStream(), System.err);
+        }
+
+        /**
+         * Retrieves the amount of time to wait for the startup.
+         *
+         * @return The amount of time to wait in seconds(?).
+         */
+        public int getStartupTime()
+        {
+            return 60;
+        }
+    }
+
+
+
+    private static class StreamProcessor extends Thread
+    {
+        private final java.io.InputStream m_in;
+        private final java.io.PrintStream m_print;
+
+        public StreamProcessor(final java.io.InputStream in, final java.io.PrintStream out)
+        {
+            super("StreamProcessor");
+
+            m_in = in;
+            m_print = out;
+            start();
+        }
+
+        @Override
+        public void run() {
+            try {
+                java.io.BufferedReader r = new java.io.BufferedReader(
+                    new java.io.InputStreamReader(m_in, "UTF-8") );
+
+                for ( ; ; ) {
+                    String s = r.readLine();
+                    if ( s == null ) {
+                        break;
+                    }
+                    m_print.println(s);
+                }
+            } catch ( UnsupportedEncodingException e ) {
+                e.printStackTrace( System.err );
+            } catch ( java.io.IOException e ) {
+                e.printStackTrace( System.err );
+            }
+        }
+    }
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bean/com/sun/star/comp/beans/LocalOfficeWindow.java b/bean/com/sun/star/comp/beans/LocalOfficeWindow.java
new file mode 100644
index 000000000..2e04a00c7
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/LocalOfficeWindow.java
@@ -0,0 +1,268 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import java.awt.Component;
+
+import com.sun.star.lang.EventObject;
+import com.sun.star.lang.SystemDependent;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.lang.XMultiServiceFactory;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.awt.Rectangle;
+import com.sun.star.awt.XWindow;
+import com.sun.star.awt.XWindowPeer;
+import com.sun.star.awt.XVclWindowPeer;
+import com.sun.star.awt.XToolkit;
+import com.sun.star.awt.WindowDescriptor;
+import com.sun.star.awt.WindowAttribute;
+import com.sun.star.awt.WindowClass;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.uno.Any;
+import com.sun.star.uno.Type;
+import com.sun.star.beans.NamedValue;
+
+/**
+ * This class represents a local office window.
+ *
+ * @since OOo 2.0.0
+ */
+public class LocalOfficeWindow
+    extends java.awt.Canvas
+    implements OfficeWindow, XEventListener
+{
+    private transient OfficeConnection  mConnection;
+    private transient XWindowPeer       mParentProxy;
+    private transient XWindowPeer       mWindow;
+    private boolean             bPeer = false;
+
+    /**
+     * Constructor.
+     *
+     * @param connection The office connection object the window
+     *  belongs to.
+     */
+    protected LocalOfficeWindow(OfficeConnection connection)
+    {
+        mConnection = connection;
+        mConnection.addEventListener(this);
+    }
+
+    /**
+     * Retrieves an AWT component object associated with the OfficeWindow.
+     *
+     * @return The AWT component object associated with the OfficeWindow.
+     */
+    public Component getAWTComponent()
+    {
+        return this;
+    }
+
+    /**
+     * Receives a notification about the connection has been closed.
+     * This method has to set the connection to <code>null</code>.
+     *
+     * @param source The event object.
+     */
+    public synchronized void disposing(EventObject source)
+    {
+        // the window will be disposed by the framework
+        mWindow = null;
+        mConnection = null;
+    }
+
+    /**
+     * Returns an AWT toolkit.
+     */
+    private XToolkit queryAWTToolkit() throws com.sun.star.uno.Exception
+    {
+         // Create a UNO toolkit.
+         XComponentContext xContext = mConnection.getComponentContext();
+         if (xContext == null)
+             throw new RuntimeException("no context");
+         XMultiComponentFactory compfactory = xContext.getServiceManager();
+         XMultiServiceFactory factory = UnoRuntime.queryInterface(
+                 XMultiServiceFactory.class, compfactory);
+         Object object  = factory.createInstance( "com.sun.star.awt.Toolkit");
+         return UnoRuntime.queryInterface(XToolkit.class, object);
+    }
+
+    /// called when system parent is available, reparents the bean window
+    private synchronized void aquireSystemWindow()
+    {
+        if ( !bPeer )
+        {
+            // set real parent
+            XVclWindowPeer xVclWindowPeer = UnoRuntime.queryInterface(
+                               XVclWindowPeer.class, mWindow);
+
+            xVclWindowPeer.setProperty( "PluginParent", getWrappedWindowHandle());
+            bPeer = true;
+            // show document window
+            XWindow aWindow = UnoRuntime.queryInterface(XWindow.class, mWindow);
+            aWindow.setVisible( true );
+        }
+    }
+
+           /// called when system parent is about to die, reparents the bean window
+    private synchronized void releaseSystemWindow()
+    {
+        if ( bPeer )
+        {
+                   // hide document window
+            XWindow aWindow = UnoRuntime.queryInterface(XWindow.class, mWindow);
+            aWindow.setVisible( false );
+
+            // set null parent
+            XVclWindowPeer xVclWindowPeer = UnoRuntime.queryInterface(
+                               XVclWindowPeer.class, mWindow);
+            xVclWindowPeer.setProperty( "PluginParent", Long.valueOf(0) );
+            bPeer = false;
+        }
+    }
+
+
+    /// Overriding java.awt.Component.setVisible() due to Java bug (no showing event).
+    @Override
+    public void setVisible( boolean b )
+    {
+        super.setVisible(b);
+
+        // Java-Bug: componentShown() is never called :-(
+        // is still at least in Java 1.4.1_02
+        if ( b )
+            aquireSystemWindow();
+        else
+            releaseSystemWindow();
+    }
+
+    /**
+     * Retrieves a UNO XWindowPeer object associated with the OfficeWindow.
+     *
+     * @return The UNO XWindowPeer object associated with the OfficeWindow.
+     */
+    public synchronized XWindowPeer getUNOWindowPeer()
+    {
+        if (mWindow != null)
+            return mWindow;
+
+        try
+        {
+            // get this windows native window type
+            int type = getNativeWindowSystemType();
+
+            // Java AWT windows only have a system window when showing.
+            XWindowPeer parentPeer;
+            if ( isShowing() )
+            {
+                // create direct parent relationship
+                parentPeer = new JavaWindowPeerFake(getWrappedWindowHandle(), type);
+                bPeer = true;
+                        }
+                        else
+            {
+                // no parent yet
+                parentPeer = null;
+                bPeer = false;
+            }
+
+            // create native window (mWindow)
+            Rectangle aRect = new Rectangle( 0, 0, 20, 20 );
+            WindowDescriptor desc = new WindowDescriptor();
+            desc.Type = WindowClass.TOP;
+            desc.Parent = parentPeer;
+            desc.Bounds = aRect;
+            desc.WindowServiceName = "workwindow";
+            desc.WindowAttributes = (type == SystemDependent.SYSTEM_WIN32)
+                ? WindowAttribute.SHOW : 0;
+            mWindow = queryAWTToolkit().createWindow(desc);
+
+
+            // set initial visibility
+            XWindow aWindow = UnoRuntime.queryInterface(XWindow.class, mWindow);
+            aWindow.setVisible( bPeer );
+        }
+        catch (com.sun.star.uno.Exception exp) {
+        }
+
+        return mWindow;
+    }
+
+    /** We make sure that the office window is notified that the parent
+     *  will be removed.
+     */
+    @Override
+    public void removeNotify()
+    {
+        try {
+            releaseSystemWindow();
+        } catch (java.lang.Exception e) {
+            System.err.println("LocaleOfficeWindow.removeNotify: Exception in releaseSystemWindow.");
+            System.err.println(e.getMessage());
+            e.printStackTrace(System.err);
+        }
+        super.removeNotify();
+    }
+
+    /**
+     * Retrieves a platform dependent system window identifier.
+     *
+     * @return The system window identifier.
+     */
+    private native long getNativeWindow();
+
+    /**
+     * Retrieves a platform dependent system window type.
+     *
+     * @return The system window type.
+     */
+    private native int getNativeWindowSystemType();
+
+    /**
+     * Returns an Any containing a sequences of com.sun.star.beans.NamedValue. One NamedValue
+     * contains the name "WINDOW" and the value is a Long representing the window handle.
+     * The second NamedValue  has the name "XEMBED" and the value is true, when the XEmbed
+     * protocol shall be used for embedding the native Window.
+    */
+    protected Any getWrappedWindowHandle()
+    {
+
+        NamedValue window = new NamedValue(
+            "WINDOW", new Any(new Type(Long.class), Long.valueOf(getNativeWindow())));
+        NamedValue xembed = new NamedValue(
+            "XEMBED", new Any(new Type(Boolean.class), Boolean.FALSE));
+
+        if (getNativeWindowSystemType() == SystemDependent.SYSTEM_XWINDOW )
+        {
+            String vendor = System.getProperty("java.vendor");
+            if ((vendor.equals("Sun Microsystems Inc.") || vendor.equals("Oracle Corporation"))
+                && Boolean.getBoolean("sun.awt.xembedserver"))
+            {
+                xembed = new NamedValue(
+                    "XEMBED",
+                    new Any(new Type(Boolean.class), Boolean.TRUE));
+            }
+        }
+        return new Any(
+            new Type("[]com.sun.star.beans.NamedValue"),
+            new NamedValue[] {window, xembed});
+    }
+
+}
diff --git a/bean/com/sun/star/comp/beans/NativeConnection.java b/bean/com/sun/star/comp/beans/NativeConnection.java
new file mode 100644
index 000000000..dd253134e
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/NativeConnection.java
@@ -0,0 +1,54 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.connection.XConnection;
+
+/* Connection to a locally running OOo instance.
+ *
+ * @deprecated.
+ */
+@Deprecated
+class NativeConnection
+    implements XConnection
+{
+    public native void connect(NativeService aNativeService)
+        throws com.sun.star.io.IOException;
+
+    public native int read(/*OUT*/ byte[][] aReadBytes, /*IN*/ int nBytesToRead)
+        throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
+
+    public native void write(/*IN*/ byte[] aData)
+        throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
+
+    public native void flush()
+        throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
+
+    public native void close()
+        throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
+
+    public synchronized String getDescription()
+        throws com.sun.star.uno.RuntimeException
+    {
+        return Description;
+    }
+
+    private long    NativeHandle;
+    private String  Description;
+}
diff --git a/bean/com/sun/star/comp/beans/NativeService.java b/bean/com/sun/star/comp/beans/NativeService.java
new file mode 100644
index 000000000..c1e828296
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/NativeService.java
@@ -0,0 +1,29 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+/*
+ * @deprecated
+ */
+    @Deprecated
+interface NativeService {
+    String getIdentifier();
+    void startupService() throws java.io.IOException;
+    int getStartupTime();
+}
diff --git a/bean/com/sun/star/comp/beans/NoConnectionException.java b/bean/com/sun/star/comp/beans/NoConnectionException.java
new file mode 100644
index 000000000..76821b8cb
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/NoConnectionException.java
@@ -0,0 +1,36 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+/** This exception is called when a method is called which
+    needs an established connection but no connection is
+    established yet.
+
+    @since OOo 2.0.0
+ */
+public class NoConnectionException extends Exception
+{
+
+    public NoConnectionException() {}
+
+    public NoConnectionException(Throwable cause) { super(cause); }
+
+}
+
+
diff --git a/bean/com/sun/star/comp/beans/NoDocumentException.java b/bean/com/sun/star/comp/beans/NoDocumentException.java
new file mode 100644
index 000000000..f3abb20bf
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/NoDocumentException.java
@@ -0,0 +1,29 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+/** Indicates that an operation needed a document, but no document was loaded.
+
+    @since OOo 2.0.0
+ */
+public class NoDocumentException extends Exception
+{
+}
+
+
diff --git a/bean/com/sun/star/comp/beans/OOoBean.java b/bean/com/sun/star/comp/beans/OOoBean.java
new file mode 100644
index 000000000..05b5288ea
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/OOoBean.java
@@ -0,0 +1,1515 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.uno.UnoRuntime;
+
+// @requirement FUNC.PERF.LRN/0.6
+// @requirement FUNC.PERF.LOC/0.6
+// @requirement FUNC.PERF.FIX/0.6
+// @requirement FUNC.RES.OTH/0.2
+// No other resources are needed yet.
+/** This is the basic JavaBean for all OOo application modules.
+    @since OOo 2.0.0
+ */
+public class OOoBean
+
+    // @requirement FUNC.BEAN.VIEW/0.4
+    extends java.awt.Container
+
+    implements
+        // @requirement FUNC.PER/0.2
+        java.io.Externalizable
+{
+    // timeout values (milli secs)
+    private int nOOoStartTimeOut = 60000;
+    private int nOOoCallTimeOut =   3000;
+    private int nOOoCheckCycle =    1000;
+
+    // This member contains the connection to an OOo instance if established.
+    private transient OfficeConnection      iConnection;
+    private transient EventListener         xConnectionListener;
+
+    // @requirement FUNC.BEAN.VIEW/0.4
+    // @requirement FUNC.BEAN.EDIT/0.4
+    // This member contains the OOo window if a connection is established.
+    // It is a child of the OOoBean canvas.
+    private OfficeWindow xFrameWindow;
+
+    // application environment
+    private transient com.sun.star.lang.XMultiServiceFactory xServiceFactory;
+    private transient com.sun.star.frame.XDesktop xDesktop;
+
+    // document and frame
+    private transient Frame aFrame;
+    private transient Controller aController;
+    private transient OfficeDocument aDocument;
+
+    // slot command execution environment
+    private transient com.sun.star.util.XURLTransformer xURLTransformer;
+
+    // properties
+    private boolean bIgnoreVisibility = false; // to show even if already visible
+    private boolean bMenuBarVisible = true;
+    private boolean bStandardBarVisible = true;
+    private boolean bToolBarVisible = true;
+    private boolean bStatusBarVisible = true;
+
+
+    // debugging method
+    private void dbgPrint( String aMessage )
+    {
+    }
+
+    // @requirement FUNC.PER/0.2
+    // @internal
+    /**
+     */
+    @Deprecated
+    public void writeExternal( java.io.ObjectOutput aObjOut )
+    {
+        // TBD
+    }
+
+    // @requirement FUNC.PER/0.2
+    // @internal
+    /**
+     */
+    @Deprecated
+    public void readExternal( java.io.ObjectInput aObjIn )
+    {
+        // TBD
+    }
+
+    /** Generic constructor of the OOoBean.
+
+        Neither a connection is established nor any document loaded.
+     */
+    public OOoBean()
+    {
+        setLayout(new java.awt.BorderLayout());
+    }
+
+       // @requirement FUNC.CON.MULT/0.3
+    /** Constructor for an OOoBean which uses a specific office connection.
+
+        The connection must be established but no document is loaded.
+
+        @throws NoConnectionException
+            if the connection is not established.
+
+        @deprecated Clients could use the getOOoConnection to obtain an OfficeConnection
+        and use it as argument in a constructor for another OOoBean instance. Calling
+        the dispose method of the OfficeConnection or the OOoBean's stopOOoConnection
+        method would make all instances of OOoBean stop working.
+     */
+    @Deprecated
+    public OOoBean( OfficeConnection iConnection )
+        throws NoConnectionException
+    {
+        setLayout(new java.awt.BorderLayout());
+        try { setOOoConnection( iConnection ); }
+        catch ( HasConnectionException aExc )
+        { /* impossible here */ }
+    }
+
+    /** Sets the timeout for methods which launch OOo in milliseconds.
+
+        This method does not need a connection to an OOo instance.
+     */
+    public void setOOoStartTimeOut( int nMilliSecs )
+    {
+        nOOoStartTimeOut = nMilliSecs;
+    }
+
+    /** Sets the timeout for normal OOO methods calls in milliseconds.
+
+        This method does not need a connection to an OOo instance.
+     */
+    public void setOOoCallTimeOut( int nMilliSecs )
+    {
+        nOOoCallTimeOut = nMilliSecs;
+    }
+
+    /** Sets the period length in milliseconds to check the OOo connection.
+
+        This method does not need a connection to an OOo instance.
+     */
+    public void setOOoCheckCycle( int nMilliSecs )
+    {
+        nOOoCheckCycle = nMilliSecs;
+    }
+
+    // @internal
+    /** Sets a connection to an OOo instance.
+     */
+    private synchronized void setOOoConnection(OfficeConnection iNewConnection)
+            throws HasConnectionException, NoConnectionException {
+        // the connection cannot be exchanged
+        if (iConnection != null)
+            throw new HasConnectionException();
+
+        // is there a real connection, not just the proxy?
+        com.sun.star.uno.XComponentContext xComponentContext = null;
+        try {
+            xComponentContext = iNewConnection.getComponentContext();
+        } catch (java.lang.Throwable aExc) {
+            throw new NoConnectionException(aExc);
+        }
+        if (xComponentContext == null)
+            throw new NoConnectionException();
+
+        // set the connection
+        iConnection = iNewConnection;
+
+        // get notified when connection dies
+        if (xConnectionListener != null)
+            xConnectionListener.end();
+        xConnectionListener = this.new EventListener("setOOoConnection");
+    }
+
+    // @requirement FUNC.CON.STRT/0.4
+    /** Starts a connection to an OOo instance which is launched if not running.
+
+        @throws HasConnectionException
+            if a connection was already established.
+
+        @throws NoConnectionException
+            if the specified connection cannot be established
+     */
+    public void startOOoConnection( String aConnectionURL )
+        throws  java.net.MalformedURLException,
+            HasConnectionException,
+            NoConnectionException
+    {
+        // create a new connection from the given connection URL
+        LocalOfficeConnection aConnection = new LocalOfficeConnection();
+        aConnection.setUnoUrl( aConnectionURL );
+        setOOoConnection( aConnection );
+    }
+
+    // @requirement FUNC.CON.CHK/0.7
+    /** Returns true if this OOoBean is connected to an OOo instance,
+        false otherwise.
+
+        @deprecated This method is not useful in a multithreaded environment. Then
+        all threads accessing the instance would have to be synchronized in order to
+        make is method work. It is better to call OOoBean's methods and be prepared
+        to catch a NoConnectionException.
+     */
+    @Deprecated
+    public boolean isOOoConnected()
+    {
+        return iConnection != null;
+    }
+
+    // @requirement FUNC.CON.STOP/0.4
+    /** Disconnects from the connected OOo instance.
+
+        If there was no connection yet or anymore, this method can be called
+        anyway.
+
+        When the OOoBean is displayed in an applet by a web browser, then this
+        method must be called from within java.applet.Applet.stop.
+     */
+    public synchronized void stopOOoConnection()
+    {
+        // clear OOo document, frame etc.
+        clear();
+
+        // cut the connection
+        OfficeConnection iExConnection = iConnection;
+        if ( iConnection != null )
+        {
+            if ( xConnectionListener != null )
+            {
+                xConnectionListener.end();
+            }
+            iConnection = null;
+            iExConnection.dispose();
+        }
+
+    }
+
+    // @requirement FUNC.CON.STOP/0.4 (via XComponent.dispose())
+       // @requirement FUNC.CON.NTFY/0.4 (via XComponent.addEventListener())
+    /** Returns a connection to an OOo instance.
+
+        If no connection exists, a default connection will be created. An OfficeConnection
+        can be used to register listeners of type com.sun.star.lang.EventListener,
+        which are notified when the connection to the office dies. One should not call the
+        dispose method, because this may result in receiving com.sun.star.lang.DisposedExceptions
+        when calling {@link #stopOOoConnection stopOOoConnection} or other API methods. If other
+        instances share the same connection then they will stop function properly, because
+        they lose their connection as well. The recommended way to end the connection is by
+        calling {@link #stopOOoConnection stopOOoConnection}.
+
+        @throws NoConnectionException
+            if no connection can be established
+
+     */
+    public synchronized OfficeConnection getOOoConnection()
+        throws NoConnectionException
+    {
+        if ( iConnection == null )
+        {
+            try { setOOoConnection( new LocalOfficeConnection() ); }
+            catch ( HasConnectionException aExc )
+            { /* impossible here */ }
+        }
+        if ( iConnection.getComponentContext() == null )
+            throw new NoConnectionException();
+        return iConnection;
+    }
+
+    /** Returns the service factory used by this OOoBean instance.
+
+        @throws NoConnectionException
+            if no connection is established and no default connection can be established.
+     */
+    public synchronized com.sun.star.lang.XMultiServiceFactory getMultiServiceFactory()
+        throws NoConnectionException
+    {
+        if ( xServiceFactory == null )
+        {
+            // avoid concurrent access from multiple threads
+            final OfficeConnection iConn = getOOoConnection();
+
+            com.sun.star.uno.XComponentContext xComponentContext = iConn.getComponentContext();
+            if (xComponentContext == null)
+                throw new NoConnectionException();
+
+            Thread aConnectorThread = new Thread("getServiceManager") {
+                @Override
+                public void run()
+                {
+                    com.sun.star.lang.XMultiComponentFactory aFactory =
+                        xComponentContext.getServiceManager();
+                    xServiceFactory = UnoRuntime.queryInterface(
+                        com.sun.star.lang.XMultiServiceFactory.class, aFactory );
+                }
+            };
+            aConnectorThread.start();
+            try { aConnectorThread.join(nOOoStartTimeOut); }
+            catch ( InterruptedException aExc )
+            { throw new NoConnectionException(aExc); }
+            if ( xServiceFactory == null )
+                throw new NoConnectionException();
+        }
+
+        return xServiceFactory;
+    }
+
+    /** Returns the XDesktop interface of the OOo instance used by this OOoBean.
+
+        @throws NoConnectionException
+            if no connection is established and no default connection can be established.
+     */
+    public synchronized com.sun.star.frame.XDesktop getOOoDesktop()
+        throws NoConnectionException
+    {
+        if ( xDesktop == null )
+        {
+            try
+            {
+                Object aObject = getMultiServiceFactory().createInstance( "com.sun.star.frame.Desktop");
+                xDesktop = UnoRuntime.queryInterface(
+                        com.sun.star.frame.XDesktop.class, aObject );
+            }
+            catch ( com.sun.star.uno.Exception aExc )
+            {} // TBD: what if no connection exists?
+        }
+
+        return xDesktop;
+    }
+
+    /** Resets this bean to an empty document.
+
+       If a document is loaded and the content modified,
+       the changes are dismissed.  Otherwise nothing happens.
+
+       This method is intended to be overridden in derived classes.
+       This implementation simply calls clear.
+
+       @param bClearStateToo
+           Not only the document content but also the state of the bean,
+        like visibility of child components is cleared.
+
+        @deprecated There is currently no way to dismiss changes, except for loading
+        of the unchanged initial document. Furthermore it is unclear how derived classes
+        handle this and what exactly their state is (e.g. what members make up their state).
+        Calling this method on a derived class requires knowledge about their implementation.
+        Therefore a deriving class should declare their own clearDocument if needed. Clients
+        should call the clearDocument of the deriving class or {@link #clear} which discards
+        the currently displayed document.
+     */
+    @Deprecated
+    public synchronized void clearDocument( boolean bClearStateToo )
+    {
+        // TBD
+        clear();
+    }
+
+    /** Resets the OOoBean to an empty status.
+
+        Any loaded document is unloaded, no matter whether it is modified or not.
+        After calling this method, the OOoBean has no office document and no frame
+        anymore.  The connection will stay, though.
+
+        This method works with or without an established connection.
+     */
+    public synchronized void clear()
+    {
+        dbgPrint( "clear()" );
+
+        try
+        {
+            CallWatchThread aCallWatchThread =
+                new CallWatchThread( nOOoCallTimeOut, "clear" );
+            // By closing the frame we avoid that dialogs are displayed, for example when
+            // the document is modified.
+            com.sun.star.util.XCloseable xCloseable = UnoRuntime.queryInterface( com.sun.star.util.XCloseable.class, aFrame );
+            if ( xCloseable != null )
+            {
+                try
+                {
+                    xCloseable.close(true);
+                }
+                catch (com.sun.star.util.CloseVetoException exc)
+                { // a print job may be running
+                }
+            }
+
+            aDocument = null;
+            aFrame = null;
+
+            // clear xFrameWindow
+            if ( xFrameWindow != null )
+            {
+                try { releaseSystemWindow(); }
+                catch ( NoConnectionException aExc )
+                {} // ignore
+                catch ( SystemWindowException aExc )
+                {} // ignore
+                remove( xFrameWindow.getAWTComponent() );
+                xFrameWindow = null;
+            }
+
+            // clear xURTTransformer
+            if ( xURLTransformer != null )
+            {
+                try
+                {
+                    com.sun.star.lang.XComponent xComp = UnoRuntime.queryInterface(
+                        com.sun.star.lang.XComponent.class, xURLTransformer );
+                    if ( xComp != null )
+                        xComp.dispose();
+                }
+                catch ( java.lang.Throwable aExc )
+                {} // ignore
+                xURLTransformer = null;
+            }
+
+            xDesktop = null;
+            xServiceFactory = null;
+
+            aCallWatchThread.cancel();
+        }
+        catch ( InterruptedException aExc )
+        { /* can be ignored */ }
+    }
+
+    // @requirement FUNC.PAR.LWP/0.4
+    /** This method causes the office window to be displayed.
+
+        If no document is loaded and the instance is added to a Java container that
+        is showing, then this method needs not to be called. If later one of the methods
+        {@link #loadFromURL loadFromURL}, {@link #loadFromStream loadFromStream1},
+        or {@link #loadFromByteArray loadFromByteArray}
+        is called, then the document is automatically displayed.
+
+        Should one of the load methods have been called before the Java container
+        was showing, then this method needs to be called after the container window
+        was made visible (java.lang.Component.setVisible(true)).
+        <p>
+        Another scenario is that an OOoBean contains a document and is removed
+        from a Java container and later added again. Then aquireSystemWindow needs
+        to be called after the container window is displayed.
+        <p>
+
+        @throws SystemWindowException
+            if no system window can be acquired.
+
+        @throws NoConnectionException
+            if the connection is not established.
+     */
+    public synchronized void aquireSystemWindow()
+        throws
+            SystemWindowException,
+
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException
+    {
+        if ( iConnection == null )
+            throw new NoConnectionException();
+        if ( !isShowing() )
+            throw new SystemWindowException();
+
+        if ( xFrameWindow != null )
+            xFrameWindow.getAWTComponent().setVisible(true);
+        doLayout();
+    }
+
+    // @requirement FUNC.PAR.RWL/0.4
+    // @estimation 16h
+    /** This method must be called when the OOoBean before the
+        system window may be released by its parent AWT/Swing component.
+
+        This is the case when java.awt.Component.isDisplayable() returns
+        true.  This is definitely the case when the OOoBean is removed
+        from its parent container.
+
+        @throws SystemWindowException
+            if system window is not acquired.
+
+        @throws NoConnectionException
+            if the connection is not established.
+
+        @deprecated When Component.removeNotify of the parent window of the actual
+        office window is called, then the actions are performed for which this method
+        needed to be called previously.
+     */
+    @Deprecated
+    public synchronized void releaseSystemWindow()
+        throws
+            SystemWindowException,
+
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException
+ {
+        if (iConnection == null)
+            throw new NoConnectionException();
+
+        try {
+            xFrameWindow.getAWTComponent().setVisible(false);
+        } catch (com.sun.star.lang.DisposedException aExc) {
+            throw new NoConnectionException(aExc);
+        }
+    }
+
+       // @requirement FUNC.BEAN.LOAD/0.4
+       // @requirement FUNC.CON.AUTO/0.3
+    /** Loads the bean from the given URL.
+
+        If a document is already loaded and the content modified,
+        the changes are dismissed.
+
+        If no connection exists, a default connection is established.
+
+        @throws IllegalArgumentException
+            if either of the arguments is out of the specified range.
+
+        @throws java.io.IOException
+            if an IO error occurs reading the resource specified by the URL.
+
+        @throws com.sun.star.comp.beans.NoConnectionException
+            if no connection can be established.
+
+        @throws com.sun.star.util.CloseVetoException
+            if the currently displayed document cannot be closed because it is
+            still be used, for example it is printed.
+     */
+    public void loadFromURL(
+            final String aURL,
+            final com.sun.star.beans.PropertyValue aArguments[] )
+        throws
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException,
+            java.io.IOException,
+            com.sun.star.lang.IllegalArgumentException,
+            com.sun.star.util.CloseVetoException
+    {
+        dbgPrint( "loadFromURL()" );
+         // try loading
+        try
+        {
+            boolean bLoaded = false;
+            while ( !bLoaded )
+            {
+                // watch loading in a thread with a timeout (if OOo hangs)
+                CallWatchThread aCallWatchThread =
+                    new CallWatchThread( nOOoStartTimeOut, "loadFromURL" );
+
+                try
+                {
+                    // get window from OOo on demand
+                    if ( xFrameWindow == null )
+                    {
+                        // Establish the connection by request of the ServiceFactory.
+                        getMultiServiceFactory();
+
+                        // remove existing child windows
+                        removeAll();
+
+                        // Create the OfficeWindow.
+                        xFrameWindow = getOOoConnection().createOfficeWindow(OOoBean.this);
+                        add( xFrameWindow.getAWTComponent() );
+                    }
+
+                    // create the document frame from UNO window.
+                    if ( aFrame == null )
+                    {
+                        // create the frame
+                        com.sun.star.awt.XWindow xWindow =
+                            UnoRuntime.queryInterface(
+                        com.sun.star.awt.XWindow.class, xFrameWindow.getUNOWindowPeer());
+                        Object xFrame = xServiceFactory.createInstance( "com.sun.star.frame.Frame");
+                        aFrame = new Frame( UnoRuntime.queryInterface(
+                                com.sun.star.frame.XFrame.class, xFrame ) );
+                        aFrame.initialize( xWindow );
+                        aFrame.setName( aFrame.toString() );
+
+                        // register the frame at the desktop
+                        com.sun.star.frame.XFrames xFrames =
+                                UnoRuntime.queryInterface(
+                                com.sun.star.frame.XFramesSupplier.class, getOOoDesktop() ).getFrames();
+                        xFrames.append( aFrame );
+                    }
+
+                    // Initializes the slot command execution environment.
+                    xURLTransformer = UnoRuntime.queryInterface(
+                        com.sun.star.util.XURLTransformer.class,
+                        xServiceFactory.createInstance( "com.sun.star.util.URLTransformer") );
+
+                    try
+                    {
+                        UnoRuntime.queryInterface(com.sun.star.frame.XDispatchProvider.class, aFrame);
+                    }
+                    catch (Exception e)
+                    {
+                        /*ignore!*/
+                    }
+
+                    // get XComponentLoader from frame
+                    com.sun.star.frame.XComponentLoader xLoader = UnoRuntime.queryInterface( com.sun.star.frame.XComponentLoader.class, aFrame );
+                    if ( xLoader == null )
+                    {
+                        throw new java.lang.RuntimeException(
+                            "com.sun.star.frame.Frame(" + aFrame +
+                                ") without com.sun.star.frame.XComponentLoader" );
+                    }
+
+                    // Avoid dialog 'Document changed' while reloading
+                    if ( aDocument != null )
+                    {
+                        try {
+                            aDocument.setModified(false);
+                        } catch (com.sun.star.beans.PropertyVetoException ep) {
+                            // it doesn't make sense to throw the exception here. The interface does not
+                            // offer a way to add/remove respective listeners.
+                        } catch (com.sun.star.lang.DisposedException ed) {
+                            // can be disposed if user closed document via UI
+                        }
+
+                        com.sun.star.frame.XController xOldController = null;
+                        if ( aFrame != null )
+                            xOldController = aFrame.getController();
+
+                        try
+                        {
+
+                            if ( aFrame != null && xOldController != null )
+                                if (!xOldController.suspend(true))
+                                    throw new com.sun.star.util.CloseVetoException(
+                                            "Document is still being used and cannot be closed.", this);
+
+                        }
+                        catch (java.lang.IllegalStateException exp)
+                        {}
+                    }
+
+                    // load the document.
+                    com.sun.star.beans.PropertyValue aArgs[] =
+                        addArgument( aArguments, new com.sun.star.beans.PropertyValue(
+                            "MacroExecutionMode", -1,
+                            Short.valueOf( com.sun.star.document.MacroExecMode.USE_CONFIG ),
+                            com.sun.star.beans.PropertyState.DIRECT_VALUE ) );
+
+                    com.sun.star.lang.XComponent xComponent = xLoader.loadComponentFromURL(
+                        aURL, "_self", 0, aArgs );
+
+                    // nothing loaded?
+                    if ( xComponent == null && aDocument != null )
+                    {
+                        // reactivate old document
+                        if ( aFrame != null && aFrame.getController() != null )
+                        {
+                            boolean bResult = aFrame.getController().suspend(false);
+                            dbgPrint( "loadFromURL() .. suspend() -> " + bResult );
+                        }
+                        aDocument.setModified(true);
+
+                        // throw exception
+                        throw new java.io.IOException(
+                            "Can not load a document: \"" + aURL + "\"");
+                    }
+
+                    // Get document's XModifiable interface if any.
+                    aDocument = new OfficeDocument(
+                        UnoRuntime.queryInterface(
+                        com.sun.star.frame.XModel.class, xComponent ) );
+                    bLoaded = true;
+                }
+                catch ( NoConnectionException aExc )
+                {
+                    // stop, clear and retry
+                    stopOOoConnection();
+                }
+                catch ( com.sun.star.lang.DisposedException aExc )
+                {
+                    // stop, clear and retry
+                    stopOOoConnection();
+                }
+                catch ( com.sun.star.uno.Exception aExc )
+                {
+                    // TDB: handling failure in createInstance
+                    java.io.IOException ex2 = new java.io.IOException();
+                    ex2.initCause(aExc);
+                    throw ex2;
+                }
+
+                aCallWatchThread.cancel();
+                if ( xServiceFactory == null )
+                    throw new NoConnectionException();
+            }
+            if ( iConnection == null )
+            {
+                throw new NoConnectionException();
+            }
+
+            applyToolVisibilities();
+        }
+        catch ( InterruptedException aExc )
+        {
+            throw new NoConnectionException(aExc);
+        }
+    }
+
+    /** Loads a document from a Java stream.
+
+           See loadFromURL() for further information.
+     */
+    public void loadFromStream(
+            final java.io.InputStream iInStream,
+            final com.sun.star.beans.PropertyValue aArguments[] )
+        throws
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException,
+            java.io.IOException,
+            com.sun.star.lang.IllegalArgumentException,
+            com.sun.star.util.CloseVetoException
+    {
+        // wrap Java stream into UNO stream
+
+                 // copy stream...
+                 int s = 4096;
+                 int r=0 ,n = 0;
+                 byte[] buffer = new byte[s];
+                 byte[] newBuffer = null;
+                 while ((r = iInStream.read(buffer, n, buffer.length-n))>0) {
+                     n += r;
+                     if (iInStream.available() > buffer.length - n) {
+                         newBuffer = new byte[buffer.length*2];
+                         System.arraycopy(buffer, 0, newBuffer, 0, n);
+                         buffer = newBuffer;
+                     }
+                }
+                if (buffer.length != n) {
+                    newBuffer = new byte[n];
+                    System.arraycopy(buffer, 0, newBuffer, 0, n);
+                    buffer = newBuffer;
+                }
+                com.sun.star.io.XInputStream xStream =
+                    new com.sun.star.lib.uno.adapter.ByteArrayToXInputStreamAdapter(buffer);
+
+        // add stream to arguments
+        com.sun.star.beans.PropertyValue[] aExtendedArguments =
+            addArgument( aArguments, new com.sun.star.beans.PropertyValue(
+                "InputStream", -1, xStream, com.sun.star.beans.PropertyState.DIRECT_VALUE ) );
+
+        // call normal load method
+        loadFromURL( "private:stream", aExtendedArguments );
+    }
+
+    /** Loads a document from a byte array.
+
+           See loadFromURL() for further information.
+     */
+    public void loadFromByteArray(
+            final byte aInBuffer[],
+            final com.sun.star.beans.PropertyValue aArguments[] )
+        throws
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException,
+            java.io.IOException,
+            com.sun.star.lang.IllegalArgumentException,
+            com.sun.star.util.CloseVetoException
+    {
+        // wrap byte array into UNO stream
+        com.sun.star.io.XInputStream xStream =
+                new com.sun.star.lib.uno.adapter.ByteArrayToXInputStreamAdapter(
+                    aInBuffer );
+
+        // add stream to arguments
+        com.sun.star.beans.PropertyValue[] aExtendedArguments =
+            addArgument( aArguments, new com.sun.star.beans.PropertyValue(
+                "InputStream", -1, xStream, com.sun.star.beans.PropertyState.DIRECT_VALUE ) );
+
+        // call normal load method
+        loadFromURL( "private:stream", aExtendedArguments );
+    }
+
+    /** Stores a document to the given URL.
+        <p>
+        Due due a bug (50651) calling this method may cause the office to crash,
+        when at the same time the office writes a backup of the document. This bug
+        also affects {@link #storeToByteArray storeToByteArray} and
+        {@link #storeToStream storeToStream}. The workaround
+        is to start the office with the option --norestore, which disables the automatic
+        backup and recovery mechanism. OOoBean offers currently no supported way of providing
+        startup options for OOo. But it is possible to set a Java property when starting
+        Java, which is examined by OOoBean:
+        <pre>
+            java -Dcom.sun.star.officebean.Options=--norestore  ...
+        </pre>
+        It is planned to offer a way of specifying startup options in a future version.
+        The property can be used until then. When using this property only one option
+        can be provided.
+
+        @throws IllegalArgumentException
+            if either of the arguments is out of the specified range.
+
+        @throws java.io.IOException
+            if an IO error occurs reading the resource specified by the URL.
+
+        @throws com.sun.star.comp.beans.NoConnectionException
+            if no connection is established.
+
+        @throws NoDocumentException
+            if no document is loaded
+     */
+    public void storeToURL(
+            final String aURL,
+            final com.sun.star.beans.PropertyValue aArguments[] )
+        throws
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException,
+            java.io.IOException,
+            com.sun.star.lang.IllegalArgumentException,
+            NoDocumentException
+ {
+        // no document available?
+        if (aDocument == null)
+            throw new NoDocumentException();
+
+        try {
+            // start runtime timeout
+            CallWatchThread aCallWatchThread = new CallWatchThread(
+                    nOOoCallTimeOut, "storeToURL");
+
+            // store the document
+            try {
+                aDocument.storeToURL(aURL, aArguments);
+            } catch (com.sun.star.io.IOException aExc) {
+                java.io.IOException ex2 = new java.io.IOException();
+                ex2.initCause(aExc);
+                throw ex2;
+            }
+
+            // end runtime timeout
+            aCallWatchThread.cancel();
+        } catch (java.lang.InterruptedException aExc) {
+            throw new NoConnectionException(aExc);
+        }
+    }
+
+    /** Stores a document to a stream.
+
+           See {@link #storeToURL storeToURL} for further information.
+        @see #storeToURL storeToURL
+     */
+    public java.io.OutputStream storeToStream(
+            java.io.OutputStream aOutStream,
+            final com.sun.star.beans.PropertyValue aArguments[] )
+        throws
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException,
+            NoDocumentException,
+            java.io.IOException,
+            com.sun.star.lang.IllegalArgumentException
+
+    {
+        // wrap Java stream into UNO stream
+        com.sun.star.lib.uno.adapter.OutputStreamToXOutputStreamAdapter aStream = new com.sun.star.lib.uno.adapter.OutputStreamToXOutputStreamAdapter(
+                aOutStream);
+
+        // add stream to arguments
+        com.sun.star.beans.PropertyValue[] aExtendedArguments = addArgument(
+                aArguments, new com.sun.star.beans.PropertyValue(
+                        "OutputStream", -1, aStream,
+                        com.sun.star.beans.PropertyState.DIRECT_VALUE));
+
+        // call normal store method
+        storeToURL("private:stream", aExtendedArguments);
+
+        // get byte array from document stream
+        try {
+            aStream.closeOutput();
+        } catch (com.sun.star.io.NotConnectedException aExc) { /* TDB */
+        } catch (com.sun.star.io.BufferSizeExceededException aExc) { /* TDB */
+        } catch (com.sun.star.io.IOException aExc) {
+            java.io.IOException ex2 = new java.io.IOException();
+            ex2.initCause(aExc);
+            throw ex2;
+        }
+        return aOutStream;
+    }
+
+    /** Stores a document to a byte array.
+
+           See {@link #storeToURL storeToURL} for further information.
+        @see #storeToURL storeToURL
+     */
+    public byte[] storeToByteArray(
+            byte aOutBuffer[],
+            final com.sun.star.beans.PropertyValue aArguments[] )
+        throws
+            // @requirement FUNC.CON.LOST/0.2
+            NoConnectionException,
+            NoDocumentException,
+            java.io.IOException,
+            com.sun.star.lang.IllegalArgumentException
+ {
+        // wrap byte array into UNO stream
+        com.sun.star.lib.uno.adapter.XOutputStreamToByteArrayAdapter aStream = new com.sun.star.lib.uno.adapter.XOutputStreamToByteArrayAdapter(
+                aOutBuffer);
+
+        // add stream to arguments
+        com.sun.star.beans.PropertyValue[] aExtendedArguments = addArgument(
+                aArguments, new com.sun.star.beans.PropertyValue(
+                        "OutputStream", -1, aStream,
+                        com.sun.star.beans.PropertyState.DIRECT_VALUE));
+
+        // call normal store method
+        storeToURL("private:stream", aExtendedArguments);
+
+        // get byte array from document stream
+        try {
+            aStream.closeOutput();
+        } catch (com.sun.star.io.NotConnectedException aExc) { /* TDB */
+        } catch (com.sun.star.io.BufferSizeExceededException aExc) { /* TDB */
+        } catch (com.sun.star.io.IOException ex1) {
+            java.io.IOException ex2 = new java.io.IOException();
+            ex2.initCause(ex1);
+            throw ex2;
+        }
+        return aStream.getBuffer();
+    }
+
+    // @requirement FUNC.BEAN.PROG/0.5
+    // @requirement API.SIM.SEAP/0.2
+    /** returns the com::sun::star::frame::Frame
+        of the bean.
+
+        @return
+            a Java class which implements all interfaces which the service
+        com::sun::star::frame::Frame implements.
+        Thus, methods can be called directly without queryInterface.
+        This feature might be implemented by UNO or explicitly coded.
+
+        @throws NoConnectionException
+            if the connection is not established.
+     */
+    public Frame getFrame()
+
+        throws
+            NoConnectionException // @requirement FUNC.CON.LOST/0.2
+    {
+        if ( iConnection == null )
+            throw new NoConnectionException();
+        return aFrame;
+    }
+
+       // @requirement FUNC.BEAN.PROG/0.5
+       // @requirement API.SIM.SEAP/0.2
+    /** returns the com::sun::star::frame::Controller of the bean.
+
+        @return
+            a Java class which implements all interfaces which the service
+        com::sun::star::frame::Controller implements.
+        Thus, methods can be called directly without queryInterface.
+        This feature might be implemented by UNO or explicitly coded.
+
+        @throws NoConnectionException
+            if the connection is not established.
+     */
+    public Controller getController()
+
+        // @requirement FUNC.CON.LOST/0.2
+        throws NoConnectionException
+    {
+        if ( iConnection == null )
+            throw new NoConnectionException();
+        if ( aController == null )
+            aController = new Controller( aFrame.getController() );
+        return aController;
+    }
+
+    // @requirement FUNC.BEAN.PROG/0.5
+    // @requirement FUNC.BEAN.STOR/0.4
+    // @requirement FUNC.BEAN.PRNT/0.4
+    // @requirement API.SIM.SEAP/0.2
+       /** returns the com::sun::star::document::OfficeDocument
+        of the bean.
+
+        @return
+            a Java class which implements all interfaces which the service
+        com::sun::star::document::OfficeDocument
+        implements.
+        Thus, methods can be called directly without queryInterface.
+        This feature might be implemented by UNO or explicitly coded.
+
+        @throws NoConnectionException
+            if the connection is not established.
+     */
+    public OfficeDocument getDocument()
+
+        // @requirement FUNC.CON.LOST/0.2
+        throws NoConnectionException
+    {
+        if ( iConnection == null )
+            throw new NoConnectionException();
+        return aDocument;
+    }
+
+    /** Sets visibility of all tool bars known by this OOoBean version.
+
+        Initially all tool bars are visible.  By hiding all tool bars
+        utilizing this method, it is possible to turn just a subset of
+        toolbars on afterwards, no matter whether all available tool
+        bars are known or not.
+        <p>
+        If an older OOoBean instance is used with a newer OOo instance,
+        some tool bars might not be affected by this method.
+        <p>
+        If no connection is established or no document is loaded,
+        the setting is memorized until a document is loaded.  Same
+        is valid when the connection dies within this function call.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. For example:
+        <pre>
+com.sun.star.beans.XPropertySet xPropSet =
+  (com.sun.star.beans.XPropertySet) UnoRuntime.queryInterface(
+    com.sun.star.beans.XPropertySet.class, aFrame );
+com.sun.star.frame.XLayoutManager xLayoutManager =
+  (com.sun.star.frame.XLayoutManager) UnoRuntime.queryInterface(
+    com.sun.star.frame.XLayoutManager.class,
+    xPropSet.getPropertyValue( "LayoutManager" ) );
+xLayoutManager.showElement("private:resource/menubar/menubar");
+        </pre>
+     */
+    @Deprecated
+    public void setAllBarsVisible( boolean bVisible )
+    {
+        bIgnoreVisibility = true;
+        setMenuBarVisible( bVisible );
+        setStandardBarVisible( bVisible );
+        setToolBarVisible( bVisible );
+        setStatusBarVisible( bVisible );
+        bIgnoreVisibility = false;
+    }
+
+
+    /** Applies all tool visibilities to the real thing.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible setAllBarsVisible}.
+     */
+    @Deprecated
+    protected void applyToolVisibilities()
+    {
+        bIgnoreVisibility = true;
+        setMenuBarVisible( bMenuBarVisible );
+        setStandardBarVisible( bStandardBarVisible );
+        setToolBarVisible( bToolBarVisible );
+        setStatusBarVisible( bStatusBarVisible );
+        bIgnoreVisibility = false;
+    }
+
+    /** Helper method to set tool bar visibility.
+
+         @param bNewValue
+            If false, the tool bar is disabled,
+            If true, the tool bar is visible.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    protected boolean setToolVisible( String aProperty, String aResourceURL,
+        boolean bOldValue, boolean bNewValue )
+
+        throws
+            InterruptedException
+    {
+        // start runtime timeout
+        CallWatchThread aCallWatchThread =
+            new CallWatchThread( nOOoCallTimeOut, "setToolVisible" );
+
+        // Does a frame exist?
+        if ( aFrame != null )
+        {
+            if ( bIgnoreVisibility || bOldValue != bNewValue )
+            {
+                try
+                {
+                    com.sun.star.beans.XPropertySet xPropSet =
+                            UnoRuntime.queryInterface(
+                    com.sun.star.beans.XPropertySet.class, aFrame );
+                    com.sun.star.frame.XLayoutManager xLayoutManager =
+                            UnoRuntime.queryInterface(
+                    com.sun.star.frame.XLayoutManager.class,
+                    xPropSet.getPropertyValue( "LayoutManager" ) );
+                    if ( bNewValue )
+                        xLayoutManager.showElement( aResourceURL );
+                    else
+                        xLayoutManager.hideElement( aResourceURL );
+                }
+                catch (  com.sun.star.beans.UnknownPropertyException aExc )
+                {
+                    throw new RuntimeException( "not layout manager found", aExc );
+                }
+                catch (  com.sun.star.lang.WrappedTargetException aExc )
+                {
+                    throw new RuntimeException( "not layout manager found", aExc );
+                }
+
+                // notify change
+                firePropertyChange( aProperty, Boolean.valueOf(bOldValue), Boolean.valueOf(bNewValue) );
+           }
+        }
+
+        // end runtime timeout
+        aCallWatchThread.cancel();
+
+        // the new value will be stored by caller
+        return bNewValue;
+    }
+
+    /** Sets the visibility of the menu bar.
+
+        Initially the menu bar is visible.
+        <p>
+        If not connected or no document loaded, the value is stored
+        and automatically applied to the document after it is loaded.
+        Same is valid when the connection dies within this function call.
+
+         @param bVisible
+            If false, the menu bar is disabled,
+            If true, the menu bar is visible.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public void setMenuBarVisible(boolean bVisible)
+    {
+        try
+        {
+            bMenuBarVisible = setToolVisible( "MenuBarVisible",
+                    "private:resource/menubar/menubar", bMenuBarVisible, bVisible );
+        }
+        catch ( InterruptedException aExc )
+        {
+            bMenuBarVisible = bVisible;
+        }
+    }
+
+      /** Returns the visibility of the menu bar.
+
+        This method works independently from a connection or loaded document.
+        If no connection is established or no document is loaded,
+        this method just returns a memorized status.
+
+        @return
+            True if the menu bar is visible,
+            false if the menu bar is hidden.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public boolean isMenuBarVisible()
+    {
+        return bMenuBarVisible;
+    }
+
+    /** Sets the main function bar visibility.
+
+        Initially the standard bar is visible.
+
+        If not connected or no document loaded, the value is stored
+        and automatically applied to the document after it is loaded.
+        Same is valid when the connection dies within this function call.
+
+         @param bVisible
+            If false, the main function bar is disabled,
+            If true, the main function bar is visible.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public void setStandardBarVisible(boolean bVisible)
+    {
+        try
+        {
+            bStandardBarVisible = setToolVisible( "StandardBarVisible",
+                    "private:resource/toolbar/standardbar", bStandardBarVisible, bVisible );
+        }
+        catch ( InterruptedException aExc )
+        {
+            bMenuBarVisible = bVisible;
+        }
+    }
+
+      /** Returns the visibility of the main function bar.
+
+           This method works independently from a connection or loaded document.
+        If no connection is established or no document is loaded,
+        this method just returns a memorized status.
+
+        @return
+            True if the main function bar is visible,
+            false if the main function bar is hidden.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+    */
+    @Deprecated
+    public boolean isStandardBarVisible()
+    {
+        return bStandardBarVisible;
+    }
+
+    /** Sets the tool function bar visibility.
+
+        Initially the tool bar is visible.
+
+        If not connected or no document loaded, the value is stored
+        and automatically applied to the document after it is loaded.
+        Same is valid when the connection dies within this function call.
+
+         @param bVisible
+            If false, the tool function bar is disabled,
+            If true, the tool function bar is visible.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public void setToolBarVisible(boolean bVisible)
+    {
+        try
+        {
+            bToolBarVisible = setToolVisible( "ToolBarVisible",
+                    "private:resource/toolbar/toolbar", bToolBarVisible, bVisible );
+        }
+        catch ( InterruptedException aExc )
+        {
+            bMenuBarVisible = bVisible;
+        }
+    }
+
+      /** Returns the visibility of the tool function bar.
+
+           This method works independently from a connection or loaded document.
+        If no connection is established or no document is loaded,
+        this method just returns a memorized status.
+
+        @return
+            True if the tool function bar is visible,
+            false if the tool function bar is hidden.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public boolean isToolBarVisible()
+    {
+        return bToolBarVisible;
+    }
+
+    /** Sets the status function bar visibility.
+
+        Initially the status bar is visible.
+
+        If not connected or no document loaded, the value is stored
+        and automatically applied to the document after it is loaded.
+        Same is valid when the connection dies within this function call.
+
+         @param bVisible
+            If false, the status function bar is disabled,
+            If true, the status function bar is visible.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public void setStatusBarVisible(boolean bVisible)
+    {
+        try
+        {
+            bStatusBarVisible = setToolVisible( "StatusBarVisible",
+                    "private:resource/statusbar/statusbar", bStatusBarVisible, bVisible );
+        }
+        catch ( InterruptedException aExc )
+        {
+            bMenuBarVisible = bVisible;
+        }
+    }
+
+      /**   Returns the visibility of the status function bar.
+
+           This method works independently from a connection or loaded document.
+        If no connection is established or no document is loaded,
+        this method just returns a memorized status.
+
+        @return
+            True if the status function bar is visible,
+            false if the status function bar is hidden.
+
+        @deprecated Clients should use the service com.sun.star.frame.LayoutManager,
+        which can be obtained from a frame, to control toolbars. See also
+        {@link #setAllBarsVisible}.
+     */
+    @Deprecated
+    public boolean isStatusBarVisible()
+    {
+        return bStatusBarVisible;
+    }
+
+
+    // Helper Methods / Internal Methods
+
+
+    @Deprecated
+    @Override
+    public void paint( java.awt.Graphics aGraphics )
+    {
+    }
+
+    /** Adds a single argument to an array of arguments.
+
+        If the argument by its name is already in aArguments
+        it is exchanged and aArguments is returned.
+        <p>
+        If the argument by its name is not yet in aArguments,
+        a new array is created, aArgument added and the new
+        array returned.
+    */
+    protected com.sun.star.beans.PropertyValue[] addArgument(
+                com.sun.star.beans.PropertyValue aArguments[],
+                final com.sun.star.beans.PropertyValue aArgument )
+    {
+        // get number of current arguments
+        int nNumArgs = 0;
+        if ( aArguments != null )
+            nNumArgs = aArguments.length;
+
+        // is new argument already set?
+        for ( int n = 0; n < nNumArgs; ++n )
+        {
+            if ( aArguments[n].Name.equals(aArgument.Name) )
+            {
+                // substitute this argument
+                aArguments[n] = aArgument;
+
+                // return current array
+                return aArguments;
+            }
+        }
+
+        // create extended arguments
+        com.sun.star.beans.PropertyValue[] aExtendedArguments =
+            new com.sun.star.beans.PropertyValue[ nNumArgs + 1 ];
+
+        // copy current arguments
+        if (aArguments != null)
+            System.arraycopy(aArguments, 0, aExtendedArguments, 0, nNumArgs);
+
+        // add new argument
+        aExtendedArguments[ nNumArgs ] = aArgument;
+
+        // return new arguments
+        return aExtendedArguments;
+    }
+
+
+    // Helper Classes
+
+    // @internal
+    /** Helper class to listen on the connection to learn when it dies.
+
+     */
+    private class EventListener
+        extends Thread
+        implements
+            com.sun.star.frame.XTerminateListener
+    {
+        String aTag;
+
+        EventListener( String aTag )
+            throws NoConnectionException
+        {
+            // init members
+            this.aTag = aTag;
+
+            // listen on a dying connection
+            iConnection.addEventListener( this );
+
+            // listen on a terminating OOo
+            com.sun.star.frame.XDesktop xDesktop = getOOoDesktop();
+            if (xDesktop != null)
+                xDesktop.addTerminateListener( this );
+
+            // start this thread as a daemon
+            setDaemon( true );
+            start();
+        }
+
+        public void end()
+        {
+            // do not listen on a dying connection anymore
+            try {
+                iConnection.removeEventListener( this );
+            }
+            catch ( Throwable aExc ) {}
+
+            // do not listen on a terminating OOo anymore
+            try {
+                com.sun.star.frame.XDesktop xDesktop = getOOoDesktop();
+                if (xDesktop != null)
+                    xDesktop.removeTerminateListener( this );
+            }
+            catch ( Throwable aExc ) {}
+
+            // stop thread
+            this.interrupt();
+        }
+
+        /// gets called when the connection dies
+        public void disposing( /*IN*/ com.sun.star.lang.EventObject Source )
+        {
+            // empty the OOoBean and cut the connection
+            stopOOoConnection();
+        }
+
+        /// gets called when the user wants to terminate OOo
+           public void queryTermination( /*IN*/ com.sun.star.lang.EventObject Event )
+            throws com.sun.star.frame.TerminationVetoException
+        {
+            // disallow termination of OOo while an OOoBean exists
+            throw new com.sun.star.frame.TerminationVetoException();
+        }
+
+        /// gets called when OOo terminates
+        public void notifyTermination( /*IN*/ com.sun.star.lang.EventObject Event )
+        {
+            // empty the OOoBean and cut the connection
+            stopOOoConnection();
+        }
+
+        /// watching the connection
+        @Override
+        public void run()
+        {
+            dbgPrint( "EventListener(" + aTag + ").run()" );
+
+            // remote call might hang => watch try
+            CallWatchThread aCallWatchThread =
+                new CallWatchThread( nOOoCallTimeOut, "EventListener(" + aTag + ")" );
+
+            // continue to trying to connect the OOo instance
+            long n = 0;
+            while ( !isInterrupted()
+                    && iConnection != null
+                    && iConnection.getComponentContext() != null )
+            {
+                dbgPrint( "EventListener(" + aTag + ").running() #" + ++n );
+
+                // still alive?
+                try
+                {
+                    // an arbitrary (but cheap) call into OOo
+                    iConnection.getComponentContext().getServiceManager();
+
+                    // call successfully performed, restart watch for next loop
+                    try
+                    {
+                        aCallWatchThread.restart();
+                    }
+                    catch ( InterruptedException aExc )
+                    {
+                        // ignore late interrupt
+                    }
+                }
+                catch ( java.lang.RuntimeException aExc )
+                {
+                    // hung
+                    OfficeConnection iDeadConn = iConnection;
+                    iConnection = null;
+                    iDeadConn.dispose();
+                }
+
+                // sleep
+                try {
+                        sleep(nOOoCheckCycle);
+                }
+                catch ( InterruptedException aExc )
+                {
+                    dbgPrint("EventListener(" + aTag + ") interrupted.");
+                    // thread can be ended by EvendListener.end();
+                    break;
+                }
+            }
+        }
+    }
+
+}
diff --git a/bean/com/sun/star/comp/beans/OfficeConnection.java b/bean/com/sun/star/comp/beans/OfficeConnection.java
new file mode 100644
index 000000000..8795f0d5a
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/OfficeConnection.java
@@ -0,0 +1,68 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import java.awt.Container;
+
+import com.sun.star.lang.XComponent;
+import com.sun.star.uno.XComponentContext;
+
+/**
+ * This abstract class represents a connection to the office
+ * application.
+ */
+@Deprecated
+public interface OfficeConnection
+    extends XComponent
+{
+    /**
+     * Sets a connection URL.
+     *
+     * @param url This is UNO URL which describes the type of a connection.
+     */
+    void setUnoUrl(String url)
+        throws java.net.MalformedURLException;
+
+    /**
+     * Sets an AWT container factory.
+     *
+     * @param containerFactory This is an application provided AWT container
+     *  factory.
+     */
+    void setContainerFactory(ContainerFactory containerFactory);
+
+    /**
+     * Retrieves the UNO component context.
+     * Establishes a connection if necessary and initialises the
+     * UNO service manager if it has not already been initialised.
+     *
+     * @return The office UNO component context.
+     */
+    XComponentContext getComponentContext();
+
+    /**
+     * Creates an office java.awt.Canvas based window.
+     *
+     * This method does not add the office window to its container.
+     *
+     * @param container This is an AWT container.
+     * @return The office window instance.
+     */
+    OfficeWindow createOfficeWindow(Container container);
+}
diff --git a/bean/com/sun/star/comp/beans/OfficeDocument.java b/bean/com/sun/star/comp/beans/OfficeDocument.java
new file mode 100644
index 000000000..10ee1ef24
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/OfficeDocument.java
@@ -0,0 +1,214 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.uno.UnoRuntime;
+
+
+/** Wrapper class for service OfficeDocument which emulates the upcoming
+     mode of automatic runtime Java classes to get rid of the need for
+    queryInterface.
+
+    See further information on the wrapping and compatibility limitations
+    in the base class Wrapper.
+
+    @since OOo 2.0.0
+ */
+public class OfficeDocument extends Wrapper
+    implements
+        com.sun.star.frame.XModel,
+        com.sun.star.util.XModifiable,
+        com.sun.star.frame.XStorable,
+        com.sun.star.view.XPrintable
+{
+    private final com.sun.star.frame.XModel xModel;
+    private final com.sun.star.util.XModifiable xModifiable;
+    private final com.sun.star.view.XPrintable xPrintable;
+    private final com.sun.star.frame.XStorable xStorable;
+
+    public OfficeDocument( com.sun.star.frame.XModel xModel )
+    {
+        super( xModel );
+
+        this.xModel = xModel;
+        this.xModifiable = UnoRuntime.queryInterface(
+            com.sun.star.util.XModifiable.class, xModel );
+        this.xPrintable = UnoRuntime.queryInterface(
+            com.sun.star.view.XPrintable.class, xModel );
+        this.xStorable = UnoRuntime.queryInterface(
+            com.sun.star.frame.XStorable.class, xModel );
+    }
+
+
+    // com.sun.star.frame.XModel
+
+
+    public boolean attachResource( /*IN*/String aURL,
+            /*IN*/com.sun.star.beans.PropertyValue[] aArguments )
+    {
+        return xModel.attachResource( aURL, aArguments );
+    }
+
+    public String getURL(  )
+    {
+        return xModel.getURL();
+    }
+
+    public com.sun.star.beans.PropertyValue[] getArgs(  )
+    {
+        return xModel.getArgs();
+    }
+
+    public void connectController(
+        /*IN*/ com.sun.star.frame.XController xController )
+    {
+        xModel.connectController( xController );
+    }
+
+    public void disconnectController(
+        /*IN*/ com.sun.star.frame.XController xController )
+    {
+        xModel.disconnectController( xController );
+    }
+
+    public void lockControllers(  )
+    {
+        xModel.lockControllers();
+    }
+
+    public void unlockControllers(  )
+    {
+        xModel.unlockControllers();
+    }
+
+    public boolean hasControllersLocked(  )
+    {
+        return xModel.hasControllersLocked();
+    }
+
+    public com.sun.star.frame.XController getCurrentController(  )
+    {
+        return xModel.getCurrentController();
+    }
+
+    public void setCurrentController(
+        /*IN*/ com.sun.star.frame.XController xController )
+        throws com.sun.star.container.NoSuchElementException
+    {
+        xModel.setCurrentController( xController );
+    }
+
+    public java.lang.Object getCurrentSelection(  )
+    {
+        return xModel.getCurrentSelection();
+    }
+
+
+    // com.sun.star.util.XModifyBroadcaster
+
+
+    public void addModifyListener(
+        /*IN*/ com.sun.star.util.XModifyListener xListener )
+    {
+        xModifiable.addModifyListener( xListener );
+    }
+
+    public void removeModifyListener(
+        /*IN*/ com.sun.star.util.XModifyListener xListener )
+    {
+        xModifiable.removeModifyListener( xListener );
+    }
+
+
+    // com.sun.star.util.XModifiable
+
+
+    public boolean isModified(  )
+    {
+        return xModifiable.isModified();
+    }
+
+    public void setModified( /*IN*/boolean bModified )
+        throws com.sun.star.beans.PropertyVetoException
+    {
+        xModifiable.setModified( bModified );
+    }
+
+
+    // com.sun.star.view.XPrintable
+
+
+    public com.sun.star.beans.PropertyValue[] getPrinter(  )
+    {
+        return xPrintable.getPrinter();
+    }
+
+    public void setPrinter( /*IN*/ com.sun.star.beans.PropertyValue[] aPrinter )
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        xPrintable.setPrinter( aPrinter );
+    }
+
+    public void print( /*IN*/ com.sun.star.beans.PropertyValue[] xOptions )
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        xPrintable.print( xOptions );
+    }
+
+
+    // com.sun.star.frame.XStorable
+
+
+    public boolean hasLocation(  )
+    {
+        return xStorable.hasLocation();
+    }
+
+    public String getLocation(  )
+    {
+        return xStorable.getLocation();
+    }
+
+    public boolean isReadonly(  )
+    {
+        return xStorable.isReadonly();
+    }
+
+    public void store(  )
+        throws com.sun.star.io.IOException
+    {
+        xStorable.store();
+    }
+
+    public void storeAsURL( /*IN*/ String aURL, /*IN*/ com.sun.star.beans.PropertyValue[] aArguments )
+        throws com.sun.star.io.IOException
+    {
+        xStorable.storeAsURL( aURL, aArguments );
+    }
+
+    public void storeToURL( /*IN*/ String aURL, /*IN*/ com.sun.star.beans.PropertyValue[] aArguments )
+        throws com.sun.star.io.IOException
+    {
+        xStorable.storeToURL( aURL, aArguments );
+    }
+
+}
+
+
+
diff --git a/bean/com/sun/star/comp/beans/OfficeWindow.java b/bean/com/sun/star/comp/beans/OfficeWindow.java
new file mode 100644
index 000000000..806f6b07a
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/OfficeWindow.java
@@ -0,0 +1,46 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import java.awt.Component;
+
+import com.sun.star.awt.XWindowPeer;
+
+/**
+ * The concrete implementation of the OfficeWindow extends an
+ * appropriate type of visual component (java.awt.Canvas for local
+ * and java.awt.Container for remote).
+ */
+@Deprecated
+public interface OfficeWindow
+{
+    /**
+     * Retrieves an AWT component object associated with the OfficeWindow.
+     *
+     * @return The AWT component object associated with the OfficeWindow.
+     */
+    Component getAWTComponent();
+
+    /**
+     * Retrieves a UNO XWindowPeer object associated with the OfficeWindow.
+     *
+     * @return The UNO XWindowPeer object associated with the OfficeWindow.
+     */
+    XWindowPeer getUNOWindowPeer();
+}
diff --git a/bean/com/sun/star/comp/beans/SystemWindowException.java b/bean/com/sun/star/comp/beans/SystemWindowException.java
new file mode 100644
index 000000000..943472669
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/SystemWindowException.java
@@ -0,0 +1,32 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+/** indicates that an operation needed a system window,
+    but no system window was acquired yet.
+
+    @see com.sun.star.comp.beans.OOoBean#aquireSystemWindow
+
+    @since OOo 2.0.0
+*/
+public class SystemWindowException extends Exception
+{
+}
+
+
diff --git a/bean/com/sun/star/comp/beans/Wrapper.java b/bean/com/sun/star/comp/beans/Wrapper.java
new file mode 100644
index 000000000..001770b9b
--- /dev/null
+++ b/bean/com/sun/star/comp/beans/Wrapper.java
@@ -0,0 +1,97 @@
+/*
+ * 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 com.sun.star.comp.beans;
+
+import com.sun.star.uno.UnoRuntime;
+
+
+/** Wrapper base class for UNO services which emulates the upcoming
+    mode of automatic runtime Java classes to get rid of the need for
+    queryInterface.
+
+    Because it's not worth the effort to create a runtime generated wrapper
+    for this purpose, as it might be for OOo 2.0, you still have to use
+    UnoRuntime.queryInterface() for interfaces which are optional or come
+    from a subclass.  But for non optional interfaces you can already
+    directly call their methods.
+
+    This wrapper will only work for UNO objects via a bridge, not for
+    direct Java objects.
+
+    @since OOo 2.0.0
+ */
+class Wrapper
+    implements
+        com.sun.star.lib.uno.Proxy,
+            // see the comment in com.sun.star.lib.uno.bridges.java_remote
+            // .java_remote_bridge.mapInterfaceTo for the consequences of this
+            // hack
+        com.sun.star.uno.IQueryInterface,
+        com.sun.star.lang.XComponent
+{
+    private final com.sun.star.uno.IQueryInterface xQueryInterface;
+    private final com.sun.star.lang.XComponent xComponent;
+
+    public Wrapper( com.sun.star.uno.XInterface xProxy )
+    {
+        xQueryInterface = (com.sun.star.uno.IQueryInterface) xProxy;
+        xComponent = UnoRuntime.queryInterface(
+            com.sun.star.lang.XComponent.class, xProxy );
+    }
+
+
+    // com.sun.star.uno.IQueryInterface
+
+
+    public String getOid()
+    {
+        return xQueryInterface.getOid();
+    }
+
+    public boolean isSame( Object aObject )
+    {
+        return xQueryInterface.isSame( aObject );
+    }
+
+    public Object queryInterface( com.sun.star.uno.Type aType )
+    {
+        return xQueryInterface.queryInterface( aType );
+    }
+
+
+    // com.sun.star.lang.XComponent
+
+
+    public void dispose(  )
+    {
+        xComponent.dispose();
+    }
+
+    public void addEventListener( /*IN*/ com.sun.star.lang.XEventListener xListener )
+    {
+        xComponent.addEventListener( xListener );
+    }
+
+    public void removeEventListener( /*IN*/ com.sun.star.lang.XEventListener xListener )
+    {
+        xComponent.removeEventListener( xListener );
+    }
+}
+
+