| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| import com.sun.star.uno.Type; | |
| import com.sun.star.uno.UnoRuntime; | |
| import com.sun.star.uno.XComponentContext; | |
| import com.sun.star.registry.XRegistryKey; | |
| import com.sun.star.lang.XTypeProvider; | |
| import com.sun.star.lang.XServiceInfo; | |
| import com.sun.star.lang.XSingleServiceFactory; | |
| import com.sun.star.lang.XMultiServiceFactory; | |
| import com.sun.star.lang.XSingleComponentFactory; | |
| import com.sun.star.lang.XMultiComponentFactory; | |
| import com.sun.star.lib.uno.helper.Factory; | |
| import com.sun.star.comp.loader.FactoryHelper; | |
| import com.sun.star.awt.XDialog; | |
| import com.sun.star.awt.XDialogProvider2; | |
| import com.sun.star.awt.XDialogEventHandler; | |
| import com.sun.star.awt.XControl; | |
| import com.sun.star.awt.XControlModel; | |
| import com.sun.star.awt.XControlContainer; | |
| import com.sun.star.beans.XPropertySet; | |
| import com.sun.star.frame.XModel; | |
| import com.sun.star.frame.XFrame; | |
| import com.sun.star.awt.XToolkit; | |
| import com.sun.star.awt.XWindowPeer; | |
| import com.sun.star.awt.XMessageBox; | |
| import com.sun.star.awt.WindowAttribute; | |
| import com.sun.star.awt.WindowClass; | |
| import com.sun.star.awt.WindowDescriptor; | |
| import com.sun.star.awt.Rectangle; | |
| import com.sun.star.test.XTestDialogHandler; | |
| // DialogComponent implements all necessary interfaces self, this is only | |
| // for demonstration. More convenient is to use the implementation WeakBase or | |
| // ComponentBase, see implementation of TestComponentA. | |
| public class DialogComponent { | |
| // public static class _DialogComponent extends WeakBase | |
| public static class _DialogComponent | |
| implements XTypeProvider, XServiceInfo, XTestDialogHandler, XDialogEventHandler { | |
| static final String __serviceName= "com.sun.star.test.TestDialogHandler"; | |
| static byte[] _implementationId; | |
| private XComponentContext m_xCmpCtx; | |
| private XFrame m_xFrame; | |
| private XToolkit m_xToolkit; | |
| public _DialogComponent(XComponentContext context) { | |
| m_xCmpCtx= context; | |
| try { | |
| // Create the toolkit to have access to it later | |
| m_xToolkit = UnoRuntime.queryInterface( | |
| XToolkit.class, | |
| m_xCmpCtx.getServiceManager().createInstanceWithContext("com.sun.star.awt.Toolkit", | |
| m_xCmpCtx)); | |
| } | |
| catch (Exception e) { | |
| e.printStackTrace(); | |
| } | |
| } | |
| // XTestDialogHandler | |
| public String createDialog( String DialogURL, XModel xModel, XFrame xFrame ) { | |
| m_xFrame = xFrame; | |
| try { | |
| XMultiComponentFactory xMCF = m_xCmpCtx.getServiceManager(); | |
| Object obj; | |
| // If valid we must pass the XModel when creating a DialogProvider object | |
| if( xModel != null ) { | |
| Object[] args = new Object[1]; | |
| args[0] = xModel; | |
| obj = xMCF.createInstanceWithArgumentsAndContext( | |
| "com.sun.star.awt.DialogProvider2", args, m_xCmpCtx ); | |
| } | |
| else { | |
| obj = xMCF.createInstanceWithContext( | |
| "com.sun.star.awt.DialogProvider2", m_xCmpCtx ); | |
| } | |
| XDialogProvider2 xDialogProvider = | |
| UnoRuntime.queryInterface( XDialogProvider2.class, obj ); | |
| XDialog xDialog = xDialogProvider.createDialogWithHandler( DialogURL, this ); | |
| if( xDialog != null ) | |
| xDialog.execute(); | |
| } | |
| catch (Exception e) { | |
| e.printStackTrace(); | |
| } | |
| return "Created dialog \"" + DialogURL + "\""; | |
| } | |
| public void copyText( XDialog xDialog, Object aEventObject ) { | |
| XControlContainer xControlContainer = UnoRuntime.queryInterface( | |
| XControlContainer.class, xDialog ); | |
| String aTextPropertyStr = "Text"; | |
| String aText = ""; | |
| XControl xTextField1Control = xControlContainer.getControl( "TextField1" ); | |
| XControlModel xControlModel1 = xTextField1Control.getModel(); | |
| XPropertySet xPropertySet1 = UnoRuntime.queryInterface( | |
| XPropertySet.class, xControlModel1 ); | |
| try | |
| { | |
| aText = (String)xPropertySet1.getPropertyValue( aTextPropertyStr ); | |
| } | |
| catch (Exception e) { | |
| e.printStackTrace(); | |
| } | |
| XControl xTextField2Control = xControlContainer.getControl( "TextField2" ); | |
| XControlModel xControlModel2 = xTextField2Control.getModel(); | |
| XPropertySet xPropertySet2 = UnoRuntime.queryInterface( | |
| XPropertySet.class, xControlModel2 ); | |
| try | |
| { | |
| xPropertySet2.setPropertyValue( aTextPropertyStr, aText ); | |
| } | |
| catch (Exception e) { | |
| e.printStackTrace(); | |
| } | |
| showMessageBox( "DialogComponent", "copyText() called" ); | |
| } | |
| public void handleEvent() { | |
| showMessageBox( "DialogComponent", "handleEvent() called" ); | |
| } | |
| public void handleEventWithArguments( XDialog xDialog, Object aEventObject ) { | |
| showMessageBox( "DialogComponent", "handleEventWithArguments() called\n\n" + | |
| "Event Object = " + aEventObject ); | |
| } | |
| private final String aHandlerMethod1 = "doit1"; | |
| private final String aHandlerMethod2 = "doit2"; | |
| private final String aHandlerMethod3 = "doit3"; | |
| //XDialogEventHandler | |
| public boolean callHandlerMethod( /*IN*/XDialog xDialog, /*IN*/Object EventObject, /*IN*/String MethodName ) { | |
| if ( MethodName.equals( aHandlerMethod1 ) ) | |
| { | |
| showMessageBox( "DialogComponent", "callHandlerMethod() handled \"" + aHandlerMethod1 + "\"" ); | |
| return true; | |
| } | |
| else if ( MethodName.equals( aHandlerMethod2 ) ) | |
| { | |
| showMessageBox( "DialogComponent", "callHandlerMethod() handled \"" + aHandlerMethod2 + "\"" ); | |
| return true; | |
| } | |
| else if ( MethodName.equals( aHandlerMethod3 ) ) | |
| { | |
| showMessageBox( "DialogComponent", "callHandlerMethod() handled \"" + aHandlerMethod3 + "\"" ); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public String[] getSupportedMethodNames() { | |
| String[] retValue= new String[3]; | |
| retValue[0]= aHandlerMethod1; | |
| retValue[1]= aHandlerMethod2; | |
| retValue[2]= aHandlerMethod3; | |
| return retValue; | |
| } | |
| //XTypeProvider | |
| public com.sun.star.uno.Type[] getTypes( ) { | |
| Type[] retValue= new Type[4]; | |
| retValue[0]= new Type( XServiceInfo.class); | |
| retValue[1]= new Type( XTypeProvider.class); | |
| retValue[2]= new Type( XTestDialogHandler.class); | |
| retValue[3]= new Type( XDialogEventHandler.class); | |
| return retValue; | |
| } | |
| //XTypeProvider | |
| synchronized public byte[] getImplementationId( ) { | |
| if (_implementationId == null) { | |
| _implementationId= new byte[16]; | |
| int hash = hashCode(); | |
| _implementationId[0] = (byte)(hash & 0xff); | |
| _implementationId[1] = (byte)((hash >>> 8) & 0xff); | |
| _implementationId[2] = (byte)((hash >>> 16) & 0xff); | |
| _implementationId[3] = (byte)((hash >>>24) & 0xff); | |
| } | |
| return _implementationId; | |
| } | |
| /** This method is a simple helper function to used in the | |
| * static component initialisation functions as well as in | |
| * getSupportedServiceNames. | |
| */ | |
| public static String[] getServiceNames() { | |
| String[] sSupportedServiceNames = { __serviceName }; | |
| return sSupportedServiceNames; | |
| } | |
| //XServiceInfo | |
| public String[] getSupportedServiceNames() { | |
| return getServiceNames(); | |
| } | |
| //XServiceInfo | |
| public boolean supportsService( String sServiceName ) { | |
| return sServiceName.equals( __serviceName ); | |
| } | |
| //XServiceInfo | |
| public String getImplementationName() { | |
| // return DialogComponent.class.getName(); | |
| return _DialogComponent.class.getName(); | |
| } | |
| public void showMessageBox(String sTitle, String sMessage) { | |
| try { | |
| if ( null != m_xFrame && null != m_xToolkit ) { | |
| // describe window properties. | |
| WindowDescriptor aDescriptor = new WindowDescriptor(); | |
| aDescriptor.Type = WindowClass.MODALTOP; | |
| aDescriptor.WindowServiceName = new String( "infobox" ); | |
| aDescriptor.ParentIndex = -1; | |
| aDescriptor.Parent = UnoRuntime.queryInterface( | |
| XWindowPeer.class, m_xFrame.getContainerWindow()); | |
| aDescriptor.Bounds = new Rectangle(0,0,300,200); | |
| aDescriptor.WindowAttributes = WindowAttribute.BORDER | | |
| WindowAttribute.MOVEABLE | | |
| WindowAttribute.CLOSEABLE; | |
| XWindowPeer xPeer = m_xToolkit.createWindow( aDescriptor ); | |
| if ( null != xPeer ) { | |
| XMessageBox xMsgBox = UnoRuntime.queryInterface( | |
| XMessageBox.class, xPeer); | |
| if ( null != xMsgBox ) | |
| { | |
| xMsgBox.setCaptionText( sTitle ); | |
| xMsgBox.setMessageText( sMessage ); | |
| xMsgBox.execute(); | |
| } | |
| } | |
| } | |
| } catch ( com.sun.star.uno.Exception e) { | |
| // do your error handling | |
| } | |
| } | |
| } | |
| /** | |
| * Gives a factory for creating the service. | |
| * This method is called by the <code>JavaLoader</code> | |
| * <p> | |
| * @return returns a <code>XSingleComponentFactory</code> for creating | |
| * the component | |
| * @param sImplName the name of the implementation for which a | |
| * service is desired | |
| * @see com.sun.star.comp.loader.JavaLoader | |
| */ | |
| public static XSingleComponentFactory __getComponentFactory(String sImplName) | |
| { | |
| XSingleComponentFactory xFactory = null; | |
| if ( sImplName.equals( _DialogComponent.class.getName() ) ) | |
| xFactory = Factory.createComponentFactory(_DialogComponent.class, | |
| _DialogComponent.getServiceNames()); | |
| return xFactory; | |
| } | |
| /** | |
| * Writes the service information into the given registry key. | |
| * This method is called by the <code>JavaLoader</code> | |
| * <p> | |
| * @return returns true if the operation succeeded | |
| * @param regKey the registryKey | |
| * @see com.sun.star.comp.loader.JavaLoader | |
| */ | |
| // This method not longer necessary since OOo 3.4 where the component registration | |
| // was changed to passive component registration. For more details see | |
| // https://wiki.openoffice.org/wiki/Passive_Component_Registration | |
| // public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) { | |
| // return Factory.writeRegistryServiceInfo(_DialogComponent.class.getName(), | |
| // _DialogComponent.getServiceNames(), | |
| // regKey); | |
| // } | |
| } |