diff options
Diffstat (limited to 'bean/com/sun/star/comp/beans/OOoBean.java')
| -rw-r--r-- | bean/com/sun/star/comp/beans/OOoBean.java | 1515 |
1 files changed, 1515 insertions, 0 deletions
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; + } + } + } + } + +} |