diff options
Diffstat (limited to '')
45 files changed, 8146 insertions, 0 deletions
diff --git a/odk/examples/java/Inspector/Addons.xcu b/odk/examples/java/Inspector/Addons.xcu new file mode 100644 index 000000000..2ea6abdef --- /dev/null +++ b/odk/examples/java/Inspector/Addons.xcu @@ -0,0 +1,40 @@ +<?xml version='1.0' encoding='UTF-8'?> +<!-- + * 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 . +--> +<oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Addons" oor:package="org.openoffice.Office"> + <node oor:name="AddonUI"> + <node oor:name="OfficeToolBar"> + <node oor:name="org.openoffice.Office.addon.Inspector" oor:op="replace"> + <node oor:name="toolBar_Inspector" oor:op="replace"> + <prop oor:name="URL" oor:type="xs:string"> + <value>org.openoffice.Office.addon.Inspector:inspect</value> + </prop> + <prop oor:name="Title" oor:type="xs:string"> + <value xml:lang="en-US">Object Inspector</value> + </prop> + <prop oor:name="Target" oor:type="xs:string"> + <value>_self</value> + </prop> + <prop oor:name="Context" oor:type="xs:string"> + <value></value> + </prop> + </node> + </node> + </node> + </node> +</oor:component-data> diff --git a/odk/examples/java/Inspector/HideableMutableTreeNode.java b/odk/examples/java/Inspector/HideableMutableTreeNode.java new file mode 100644 index 000000000..c601d075e --- /dev/null +++ b/odk/examples/java/Inspector/HideableMutableTreeNode.java @@ -0,0 +1,106 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +import javax.swing.tree.*; + +/** + * <code>HideableMutableTreeNode</code> is a <code>DefaultMutableTreeNode</code> + * implementation that works with <code>HideableTreeModel</code>. + */ +public class HideableMutableTreeNode extends DefaultMutableTreeNode { + /** + * The node is visible flag. + */ + private boolean bIsvisible = true; + private static final String SDUMMY = "Dummy"; + + + /** + * Creates a tree node that has no parent and no children, but which + * allows children. + */ + public HideableMutableTreeNode() { + super(); + } + + /** + * Creates a tree node with no parent, no children, but which allows + * children, and initializes it with the specified user object. + * + * @param _userObject - an Object provided by the user that + * constitutes the node's data + */ + public HideableMutableTreeNode(Object _userObject) { + super(_userObject); + } + + /** + * Creates a tree node with no parent, no children, initialized with the + * specified user object, and that allows children only if specified. + * + * @param _userObject - an Object provided by the user that describes the node's data + * @param _ballowsChildren - if true, the node is allowed to have childnodes -- otherwise, it is always a leaf node + */ + public HideableMutableTreeNode(Object _userObject, boolean _ballowsChildren) { + super(_userObject, _ballowsChildren); + } + + /** + * Checks if the node is visible. + * + * @return true if the node is visible, else false + */ + public boolean isVisible() { + return this.bIsvisible; + } + + /** + * Sets if the node is visible. + * + * @param _bIsVisible true if the node is visible, else false + */ + public void setVisible(boolean _bIsVisible) { + this.bIsvisible = _bIsVisible; + } + + + public void addDummyNode(){ + removeDummyNode(); + DefaultMutableTreeNode oDefaultMutableTreeNode = new DefaultMutableTreeNode(SDUMMY); + add(oDefaultMutableTreeNode); + + } + + + public boolean removeDummyNode(){ + boolean breturn = false; + if (getChildCount() == 1){ + DefaultMutableTreeNode oDefaultMutableTreeNode = (DefaultMutableTreeNode) getChildAt(0); + if (oDefaultMutableTreeNode != null){ + if (oDefaultMutableTreeNode.getUserObject().equals(SDUMMY)){ + remove(0); + breturn = true; + } + } + } + return breturn; + } + +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/HideableTreeModel.java b/odk/examples/java/Inspector/HideableTreeModel.java new file mode 100644 index 000000000..b70d63046 --- /dev/null +++ b/odk/examples/java/Inspector/HideableTreeModel.java @@ -0,0 +1,258 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +import java.util.ArrayList; +import javax.swing.event.TreeModelEvent; +import javax.swing.event.TreeModelListener; +import javax.swing.tree.TreeModel; +import javax.swing.tree.TreeNode; +import javax.swing.tree.TreePath; + + +public class HideableTreeModel implements TreeModel { + + private ArrayList<TreeModelListener> modelListeners = new ArrayList<TreeModelListener>(); + private Object root = null; + + + public HideableTreeModel(TreeNode _root) { + super(); + setRoot(_root); + } + + + public Object getRoot() { + return this.root; + } + + + private void setRoot(Object r) { + this.root = r; + } + + + private Object[] getPathToRoot(Object node) { + return getPathToRoot(node, 0); + } + + + private Object[] getPathToRoot(Object node, int i) { + Object anode[]; + if(node == null) { + if(i == 0) { + return null; + } + anode = new Object[i]; + } else { + i++; + if(node == getRoot()) { + anode = new Object[i]; + } else { + anode = getPathToRoot(getParent(node), i); + } + anode[anode.length - i] = node; + } + return anode; + } + + + public void addTreeModelListener(TreeModelListener l) { + modelListeners.add(l); + } + + + public void removeTreeModelListener(TreeModelListener l) { + modelListeners.remove(l); + } + + + + + + public void valueForPathChanged(TreePath path, Object newValue) { + nodeChanged(path.getLastPathComponent()); + } + + + + + public void nodeInserted(Object node, Object child, int index) { + if(index < 0) { + index = getIndexOfChild(node, child); + } + if(node != null && child != null && index >= 0) { + TreePath tp = new TreePath(getPathToRoot(node)); + int[] ai = { index }; + Object[] ac = { child }; + fireTreeNodesInserted(new TreeModelEvent(this, tp, ai, ac)); + } + } + + + private void nodeRemoved(Object node, Object child, int index) { + if(node != null && child != null && index >= 0) { + TreePath tp = new TreePath(getPathToRoot(node)); + int[] ai = { index }; + Object[] ac = { child }; + fireTreeNodesRemoved(new TreeModelEvent(this, tp, ai, ac)); + } + } + + + public void nodeChanged(Object node) { + if(node != null) { + TreePath tp = new TreePath(getPathToRoot(node)); + fireTreeNodesChanged(new TreeModelEvent(this, tp, null, null)); + } + } + + + private void fireTreeNodesChanged(TreeModelEvent event) { + for(TreeModelListener l : modelListeners) { + l.treeNodesChanged(event); + } + } + + + private void fireTreeNodesInserted(TreeModelEvent event) { + for(TreeModelListener l : modelListeners) { + l.treeNodesInserted(event); + } + } + + + private void fireTreeNodesRemoved(TreeModelEvent event) { + for(TreeModelListener l : modelListeners) { + l.treeNodesRemoved(event); + } + } + + public boolean isLeaf(Object _oNode) { + if(_oNode instanceof TreeNode) { + return ((TreeNode) _oNode).isLeaf(); + } + return true; + } + + + + private Object getParent(Object node) { + if(node != getRoot() && (node instanceof TreeNode)) { + return ((TreeNode)node).getParent(); + } + return null; + } + + + private boolean isNodeVisible(Object node) { + if(node != getRoot()) { + if(node instanceof HideableMutableTreeNode) { + return ((HideableMutableTreeNode)node).isVisible(); + } + } + return true; + } + + + public boolean setNodeVisible(Object node, boolean v) { + // can't hide root + if(node != getRoot()) { + if(node instanceof HideableMutableTreeNode) { + HideableMutableTreeNode n = (HideableMutableTreeNode)node; + if(v != n.isVisible()) { + TreeNode parent = n.getParent(); + if(v) { + // need to get index after showing... + n.setVisible(v); + int index = getIndexOfChild(parent, n); + nodeInserted(parent, n, index); + } else { + // need to get index before hiding... + int index = getIndexOfChild(parent, n); + n.setVisible(v); + nodeRemoved(parent, n, index); + } + } + return true; + } + } + return false; + } + + + + + + + + + public Object getChild(Object parent, int index) { + if(parent instanceof TreeNode) { + TreeNode p = (TreeNode) parent; + for(int i = 0, j = -1; i < p.getChildCount(); i++) { + TreeNode pc = p.getChildAt(i); + if(isNodeVisible(pc)) { + j++; + } + if(j == index) { + return pc; + } + } + } + return null; + } + + + public int getChildCount(Object parent) { + int count = 0; + if(parent instanceof TreeNode) { + TreeNode p = (TreeNode) parent; + for(int i = 0; i < p.getChildCount(); i++) { + TreeNode pc = p.getChildAt(i); + if(isNodeVisible(pc)) { + count++; + } + } + } + return count; + } + + + public int getIndexOfChild(Object parent, Object child) { + int index = -1; + if(parent instanceof TreeNode && child instanceof TreeNode) { + TreeNode p = (TreeNode)parent; + TreeNode c = (TreeNode)child; + if(isNodeVisible(c)) { + index = 0; + for(int i = 0; i < p.getChildCount(); i++) { + TreeNode pc = p.getChildAt(i); + if(pc.equals(c)) { + return index; + } + if(isNodeVisible(pc)) { + index++; + } + } + } + } + return index; + } +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/Inspector.java b/odk/examples/java/Inspector/Inspector.java new file mode 100644 index 000000000..18d8d909a --- /dev/null +++ b/odk/examples/java/Inspector/Inspector.java @@ -0,0 +1,459 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Set; + +import org.openoffice.XInstanceInspector; + +import com.sun.star.awt.XMessageBox; +import com.sun.star.awt.XMessageBoxFactory; +import com.sun.star.awt.XWindowPeer; +import com.sun.star.beans.NamedValue; +import com.sun.star.beans.XPropertySet; +import com.sun.star.configuration.theDefaultProvider; +import com.sun.star.container.XNameAccess; +import com.sun.star.frame.XModel; +import com.sun.star.lang.XComponent; +import com.sun.star.lang.XMultiComponentFactory; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.lang.XSingleComponentFactory; +import com.sun.star.lib.uno.helper.Factory; +import com.sun.star.lib.uno.helper.WeakBase; +import com.sun.star.registry.XRegistryKey; +import com.sun.star.ui.dialogs.XExecutableDialog; +import com.sun.star.ui.dialogs.XFolderPicker2; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; +import com.sun.star.util.CloseVetoException; +import com.sun.star.util.XChangesBatch; +import com.sun.star.util.XCloseable; + + +/** The purpose of this class is to provide a factory for creating the service + * (<CODE>__getServiceFactory</CODE>) and writes the information into the given + * registry key (<CODE>__writeRegistryServiceInfo</CODE>). + */ +public class Inspector{ + public static final String sIDLDOCUMENTSUBFOLDER = "docs/idl/ref/"; + + + /** This class implements the method of the interface XInstanceInspector. + * Also the class implements the interfaces XServiceInfo, and XTypeProvider. + */ + public static class _Inspector extends WeakBase implements XInstanceInspector, XServiceInfo{ + + private static final String __serviceName = "org.openoffice.InstanceInspector"; + private HashMap<String, String> aApplicationHashMap = new HashMap<String, String>(); + private String sTitle = "Object Inspector"; + private ArrayList<XComponent> aHiddenDocuments = new ArrayList<XComponent>(); + private XComponentContext m_xComponentContext; + private HashMap<String, InspectorPane> aInspectorPanes = new HashMap<String, InspectorPane>(); + private XDialogProvider m_oSwingDialogProvider; + private TDocSupplier oTDocSupplier; + private Introspector m_oIntrospector = null; + // TODO: improve these strings: + private static final String sWRONGINSTALLATIONPATH = "Your selected path does not refer to an SDK-Installation!"; + /** Creates a new instance of Dialog */ + public _Inspector(XComponentContext _xComponentContext) { + m_xComponentContext = _xComponentContext; + m_oIntrospector = Introspector.getIntrospector(m_xComponentContext); + aApplicationHashMap.put("private:factory/swriter", "Text Document"); + aApplicationHashMap.put("private:factory/scalc", "Spreadsheet"); + aApplicationHashMap.put("private:factory/simpress", "Presentation"); + aApplicationHashMap.put("private:factory/sdraw", "Drawing"); + aApplicationHashMap.put("private:factory/smath", "Formula"); + m_oSwingDialogProvider = new SwingDialogProvider(this, sTitle); + } + + + public XComponentContext getXComponentContext(){ + return m_xComponentContext; + } + + + public HashMap<String, InspectorPane> getInspectorPages(){ + return aInspectorPanes; + } + + + private String getSDKPath(){ + String sRetPath = ""; + try{ + XNameAccess xNameAccess = getConfigurationAccess("org.openoffice.inspector.ObjectInspector", true); + XPropertySet xPropertySet = UnoRuntime.queryInterface(XPropertySet.class, xNameAccess); + sRetPath = (String) xPropertySet.getPropertyValue("SDKPath"); + }catch( Exception exception ) { + exception.printStackTrace(System.err); + } + return sRetPath; + } + + + public String getIDLPath(){ + String sRetPath = getSDKPath(); + if (m_oIntrospector.isValidSDKInstallationPath(sRetPath)){ + sRetPath = Introspector.addToPath(sRetPath, sIDLDOCUMENTSUBFOLDER); + } + else{ + sRetPath = ""; + } + return sRetPath; + } + + + public void openIdlFileforSelectedNode(){ + InspectorPane oInspectorPane = m_oSwingDialogProvider.getSelectedInspectorPage(); + if (oInspectorPane != null){ + XUnoNode oUnoNode = oInspectorPane.getSelectedNode(); + if (oUnoNode != null){ + String sPath = getIDLPath(); + oUnoNode.openIdlDescription(sPath); + } + } + } + + + public void assignSDKPath() { + try { + String sInstallationFolder = ""; + Object oFolderPicker = m_xComponentContext.getServiceManager().createInstanceWithContext("com.sun.star.ui.dialogs.FolderPicker", m_xComponentContext); + XFolderPicker2 xFolderPicker = UnoRuntime.queryInterface(XFolderPicker2.class, oFolderPicker); + XExecutableDialog xExecutable = UnoRuntime.queryInterface(XExecutableDialog.class, oFolderPicker); + XComponent xComponent = UnoRuntime.queryInterface(XComponent.class, oFolderPicker); + String sPath = getSDKPath(); + if (!sPath.equals("")){ + xFolderPicker.setDisplayDirectory(sPath); + } + xFolderPicker.setTitle("Add the Path to your SDK installation"); + short nResult = xExecutable.execute(); + if (nResult == com.sun.star.ui.dialogs.ExecutableDialogResults.OK){ + sInstallationFolder = xFolderPicker.getDirectory(); + if (m_oIntrospector.isValidSDKInstallationPath(sInstallationFolder)){ + XNameAccess xNameAccess = getConfigurationAccess(true); + XPropertySet xPropertySet = UnoRuntime.queryInterface(XPropertySet.class, xNameAccess); + xPropertySet.setPropertyValue("SDKPath", sInstallationFolder); + XChangesBatch xBatch = UnoRuntime.queryInterface(XChangesBatch.class, xNameAccess); + xBatch.commitChanges(); + } + else{ + XPropertySet xPropertySet = UnoRuntime.queryInterface(XPropertySet.class, xFolderPicker); + Object oWindow = xPropertySet.getPropertyValue("Window"); + XWindowPeer xWindowPeer = UnoRuntime.queryInterface(XWindowPeer.class, oWindow); + showErrorMessageBox(xWindowPeer, sTitle, sWRONGINSTALLATIONPATH); + assignSDKPath(); + } + } + xComponent.dispose(); + }catch( Exception exception ) { + exception.printStackTrace(System.err); + }} + + + private void showErrorMessageBox(XWindowPeer _xWindowPeer, String _sTitle, String _sMessage){ + try { + Object oToolkit = m_xComponentContext.getServiceManager().createInstanceWithContext("com.sun.star.awt.Toolkit", m_xComponentContext); + XMessageBoxFactory xMessageBoxFactory = UnoRuntime.queryInterface(XMessageBoxFactory.class, oToolkit); + XMessageBox xMessageBox = xMessageBoxFactory.createMessageBox(_xWindowPeer, com.sun.star.awt.MessageBoxType.ERRORBOX, com.sun.star.awt.MessageBoxButtons.BUTTONS_OK, _sTitle, _sMessage); + XComponent xComponent = UnoRuntime.queryInterface(XComponent.class, xMessageBox); + if (xMessageBox != null){ + xMessageBox.execute(); + xComponent.dispose(); + } + } catch (com.sun.star.uno.Exception ex) { + ex.printStackTrace(System.err); + }} + + + public void inspect(java.lang.Object _oUserDefinedObject, String _sTitle) throws com.sun.star.uno.RuntimeException { + try { + int nPageIndex = m_oSwingDialogProvider.getInspectorPageCount(); + SwingTreeControlProvider oSwingTreeControlProvider = new SwingTreeControlProvider(m_oSwingDialogProvider); + InspectorPane oInspectorPane = new InspectorPane(getXComponentContext(), m_oSwingDialogProvider, oSwingTreeControlProvider, getSourceCodeLanguage()); + oInspectorPane.inspect(_oUserDefinedObject, _sTitle); + getInspectorPages().put(_sTitle, oInspectorPane); + m_oSwingDialogProvider.show(nPageIndex); + }catch( Exception exception ) { + exception.printStackTrace(System.err); + }} + + + public void inspectOpenEmptyDocument(String _sApplicationDocUrl){ + XComponent xComponent = getTDocSupplier().openEmptyDocument(_sApplicationDocUrl); + String sRootTitle = aApplicationHashMap.get(_sApplicationDocUrl); + inspect(xComponent, sRootTitle); + aHiddenDocuments.add(xComponent); + } + + + public void inspectOpenDocument(String _sTDocUrl){ + String sTreeNodeName = getTDocSupplier().getTitleByTDocUrl(_sTDocUrl); + XModel xTDocModel = getTDocSupplier().getXModelByTDocUrl(_sTDocUrl); + inspect(xTDocModel, sTreeNodeName); + } + + + public void inspectSelectedNode(){ + InspectorPane oInspectorPane = m_oSwingDialogProvider.getSelectedInspectorPage(); + if (oInspectorPane != null){ + XUnoNode oUnoNode = oInspectorPane.getSelectedNode(); + Object oUnoObject = oUnoNode.getUnoObject(); + if (oUnoObject != null){ + String sNodeDescription = UnoNode.getNodeDescription(oUnoObject); + inspect(oUnoObject, sNodeDescription); + } + } + } + + + public void addSourceCodeOfSelectedNode(){ + InspectorPane oInspectorPane = m_oSwingDialogProvider.getSelectedInspectorPage(); + if (oInspectorPane != null){ + oInspectorPane.addSourceCodeOfSelectedNode(); + } + } + + + public void invokeSelectedMethod(){ + InspectorPane oInspectorPane = m_oSwingDialogProvider.getSelectedInspectorPage(); + if (oInspectorPane != null){ + oInspectorPane.invokeSelectedMethodNode(); + } + } + + + public void setSourceCodeLanguage(final int _nLanguage){ + try{ + String sLanguage = "Java"; + XNameAccess xNameAccess = getConfigurationAccess("org.openoffice.inspector.ObjectInspector", true); + XPropertySet xPropertySet = UnoRuntime.queryInterface(XPropertySet.class, xNameAccess); + switch (_nLanguage){ + case XLanguageSourceCodeGenerator.nJAVA: + sLanguage = "Java"; + break; + case XLanguageSourceCodeGenerator.nCPLUSPLUS: + sLanguage = "CPlusPlus"; + break; + case XLanguageSourceCodeGenerator.nBASIC: + sLanguage = "Basic"; + break; + default: + System.out.println("Warning: Sourcecode language is not defined!"); + } + xPropertySet.setPropertyValue("Language", sLanguage); + XChangesBatch xBatch = UnoRuntime.queryInterface(XChangesBatch.class, xNameAccess); + xBatch.commitChanges(); + for (int i = 0; i < m_oSwingDialogProvider.getInspectorPageCount(); i++){ + m_oSwingDialogProvider.getInspectorPage(i).convertCompleteSourceCode(_nLanguage); + } + }catch( Exception exception ) { + exception.printStackTrace(System.err); + }} + + + private TDocSupplier getTDocSupplier(){ + if (oTDocSupplier == null){ + oTDocSupplier = new TDocSupplier(m_xComponentContext); + } + return oTDocSupplier; + } + + public String[] getTDocUrls(){ + return getTDocSupplier().getTDocUrls(); + } + + + public String[] getTDocTitles(String[] _sTDocUrls){ + return getTDocSupplier().getTDocTitles(_sTDocUrls); + } + + + public String[][] getApplicationUrls(){ + Set<String> aSet = aApplicationHashMap.keySet(); + String[][] sReturnList = new String[aSet.size()][]; + int n= 0; + for ( Iterator<String> i = aSet.iterator(); i.hasNext(); ){ + String[] sSingleApplication = new String[2]; + sSingleApplication[0] = i.next(); + // assign the title in the second index + sSingleApplication[1] = aApplicationHashMap.get(sSingleApplication[0]); + sReturnList[n++] = sSingleApplication; + } + return sReturnList; + } + + + public void disposeHiddenDocuments(){ + int nHiddenCount = aHiddenDocuments.size(); + if (nHiddenCount > 0){ + for (int i = nHiddenCount - 1; i >= 0; i--){ + XComponent xComponent = aHiddenDocuments.get(i); + if (xComponent != null){ + try { + XCloseable xCloseable = UnoRuntime.queryInterface(XCloseable.class, xComponent); + xCloseable.close(true); + aHiddenDocuments.remove(i); + } catch (CloseVetoException ex) { + ex.printStackTrace(); + } + } + } + } + } + + + private static String[] getServiceNames() { + String[] sSupportedServiceNames = { __serviceName }; + return sSupportedServiceNames; + } + + // Implement the interface XServiceInfo + /** Get all supported service names. + * @return Supported service names. + */ + public String[] getSupportedServiceNames() { + return getServiceNames(); + } + + // Implement the interface XServiceInfo + /** Test, if the given service will be supported. + * @return Return true, if the service will be supported. + */ + public boolean supportsService( String sServiceName ) { + return sServiceName.equals( __serviceName ); + } + + // Implement the interface XServiceInfo + /** Get the implementation name of the component. + * @return Implementation name of the component. + */ + public String getImplementationName() { + return _Inspector.class.getName(); + } + + + private int getSourceCodeLanguage(){ + int nLanguage = XLanguageSourceCodeGenerator.nJAVA; + try{ + XNameAccess xNameAccess = getConfigurationAccess("org.openoffice.inspector.ObjectInspector", false); + String sLanguage = (String) xNameAccess.getByName("Language"); + if (sLanguage.toUpperCase().equals("JAVA")){ + nLanguage = XLanguageSourceCodeGenerator.nJAVA; + } + else if (sLanguage.toUpperCase().equals("BASIC")){ + nLanguage = XLanguageSourceCodeGenerator.nBASIC; + } + else if (sLanguage.toUpperCase().equals("CPLUSPLUS")){ + nLanguage = XLanguageSourceCodeGenerator.nCPLUSPLUS; + } + else{ + System.out.println("Warning: Sourcecode language " + sLanguage + " is not defined!"); + } + m_oSwingDialogProvider.selectSourceCodeLanguage(nLanguage); + }catch( Exception exception ) { + exception.printStackTrace(System.err); + } + return nLanguage; + } + + + private XNameAccess getConfigurationAccess(boolean _bUpdate){ + return getConfigurationAccess("org.openoffice.inspector.ObjectInspector", _bUpdate); + } + + + private XNameAccess getConfigurationAccess(String _sNodePath, boolean update) { + XNameAccess xNameAccess = null; + try { + String sAccess = ""; + if (update) { + sAccess = "com.sun.star.configuration.ConfigurationUpdateAccess"; + } + else{ + sAccess = "com.sun.star.configuration.ConfigurationAccess"; + } + XMultiComponentFactory xMCF = m_xComponentContext.getServiceManager(); + XMultiServiceFactory xMSFCfg = theDefaultProvider.get(this.getXComponentContext()); + Object oAccess = xMSFCfg.createInstanceWithArguments(sAccess, new Object[]{new NamedValue("nodepath", _sNodePath)}); + xNameAccess = UnoRuntime.queryInterface(XNameAccess.class, oAccess); + } catch (com.sun.star.uno.Exception e) { + } + return xNameAccess; + } + + + } + +// end of inner class + + + /** + * 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( _Inspector.class.getName() ) ) + xFactory = Factory.createComponentFactory(_Inspector.class, _Inspector.getServiceNames()); + if ( xFactory == null ) + xFactory = InspectorAddon.__getComponentFactory(sImplName); + 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 + */ + public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) { + return (Factory.writeRegistryServiceInfo(_Inspector.class.getName(), _Inspector.getServiceNames(), regKey) + && InspectorAddon.__writeRegistryServiceInfo(regKey)); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/InspectorAddon.java b/odk/examples/java/Inspector/InspectorAddon.java new file mode 100644 index 000000000..b001d17b5 --- /dev/null +++ b/odk/examples/java/Inspector/InspectorAddon.java @@ -0,0 +1,224 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import com.sun.star.beans.XPropertySet; +import com.sun.star.frame.DispatchDescriptor; +import com.sun.star.frame.XController; +import com.sun.star.frame.XDispatch; +import com.sun.star.frame.XDispatchProvider; +import com.sun.star.frame.XFrame; +import com.sun.star.frame.XModel; +import com.sun.star.frame.XStatusListener; +import com.sun.star.lang.XInitialization; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.lang.XSingleComponentFactory; +import com.sun.star.lib.uno.helper.WeakBase; +import com.sun.star.registry.XRegistryKey; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; +import com.sun.star.lib.uno.helper.Factory; + + +public class InspectorAddon { + /** This class implements the component. At least the interfaces XServiceInfo, + * XTypeProvider, and XInitialization should be provided by the service. + */ + public static class InspectorAddonImpl extends WeakBase implements XDispatchProvider, XInitialization, XServiceInfo { + private org.openoffice.XInstanceInspector xInstInspector = null; +// Dispatcher oDispatcher = null; + private XFrame m_xFrame = null; + + private static final String[] m_serviceNames = { + "org.openoffice.InstanceInspectorAddon", + "com.sun.star.frame.ProtocolHandler" }; + + private XComponentContext m_xContext = null; + + /** Creates a new instance of InspectorAddon */ + public InspectorAddonImpl(XComponentContext _xContext) { + m_xContext = _xContext; + } + + public XDispatch queryDispatch( /*IN*/com.sun.star.util.URL aURL, /*IN*/String sTargetFrameName, /*IN*/int iSearchFlags ) { + XDispatch xRet = null; + if ( aURL.Protocol.equals("org.openoffice.Office.addon.Inspector:") ) { + if ( aURL.Path.equals( "inspect" ) ){ + // Todo: Check if the frame is already administered (use hashtable) + xRet = new Dispatcher(m_xFrame); + } + } + return xRet; + } + + + public XDispatch[] queryDispatches( /*IN*/DispatchDescriptor[] seqDescripts ) { + int nCount = seqDescripts.length; + XDispatch[] lDispatcher = new XDispatch[nCount]; + for( int i=0; i<nCount; ++i ) + lDispatcher[i] = queryDispatch( seqDescripts[i].FeatureURL, seqDescripts[i].FrameName, seqDescripts[i].SearchFlags ); + return lDispatcher; + } + + + public void initialize( Object[] object ) throws com.sun.star.uno.Exception { + if ( object.length > 0 ){ + m_xFrame = UnoRuntime.queryInterface(XFrame.class, object[ 0 ] ); + } + } + + private class Dispatcher implements XDispatch{ + private XFrame m_xFrame = null; + private XModel xModel = null; + + private Dispatcher(XFrame _xFrame){ + m_xFrame = _xFrame; + if (m_xFrame != null){ + XController xController = m_xFrame.getController(); + if (xController != null){ + xModel = xController.getModel(); + } + } + } + + // XDispatch + public void dispatch( /*IN*/com.sun.star.util.URL _aURL, /*IN*/com.sun.star.beans.PropertyValue[] aArguments ) { + try{ + if ( _aURL.Protocol.equals("org.openoffice.Office.addon.Inspector:") ){ + if ( _aURL.Path.equals("inspect")){ + Object oUnoInspectObject = xModel; + com.sun.star.lang.XMultiComponentFactory xMCF = m_xContext.getServiceManager(); + if (xInstInspector == null){ + Object obj= xMCF.createInstanceWithContext("org.openoffice.InstanceInspector", m_xContext); + xInstInspector = UnoRuntime.queryInterface(org.openoffice.XInstanceInspector.class, obj); + } + if ((m_xFrame == null) || (xModel == null)){ + Object oDesktop = xMCF.createInstanceWithContext("com.sun.star.frame.Desktop", m_xContext); + m_xFrame = UnoRuntime.queryInterface(XFrame.class, oDesktop); + oUnoInspectObject = m_xFrame; + } + XPropertySet xFramePropertySet = UnoRuntime.queryInterface(XPropertySet.class, m_xFrame); + String sTitle = (String) xFramePropertySet.getPropertyValue("Title"); + String[] sTitleList = sTitle.split(" - "); + if (sTitleList.length > 0){ + sTitle = sTitleList[0]; + } + xInstInspector.inspect(oUnoInspectObject, sTitle); + } + } + } catch( Exception e ) { + System.err.println( e + e.getMessage()); + e.printStackTrace(System.err); + }} + + public void addStatusListener( /*IN*/XStatusListener xControl, /*IN*/com.sun.star.util.URL aURL ) { + } + + public void removeStatusListener( /*IN*/XStatusListener xControl, /*IN*/com.sun.star.util.URL aURL ) { + } + + + } + + + private static String[] getServiceNames() { + return m_serviceNames; + } + + // Implement the interface XServiceInfo + /** Get all supported service names. + * @return Supported service names. + */ + public String[] getSupportedServiceNames() { + return getServiceNames(); + } + + // Implement the interface XServiceInfo + /** Test, if the given service will be supported. + * @return Return true, if the service will be supported. + */ + public boolean supportsService( String sServiceName ) { + int len = m_serviceNames.length; + + for( int i=0; i < len; i++) { + if ( sServiceName.equals( m_serviceNames[i] ) ) + return true; + } + + return false; + } + + // Implement the interface XServiceInfo + /** Get the implementation name of the component. + * @return Implementation name of the component. + */ + public String getImplementationName() { + return InspectorAddonImpl.class.getName(); + } + + } + + + /** + * 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( InspectorAddonImpl.class.getName() ) ) + xFactory = Factory.createComponentFactory(InspectorAddonImpl.class, InspectorAddonImpl.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 + */ + public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) { + return Factory.writeRegistryServiceInfo(InspectorAddonImpl.class.getName(), InspectorAddonImpl.getServiceNames(), regKey); + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/InspectorPane.java b/odk/examples/java/Inspector/InspectorPane.java new file mode 100644 index 000000000..6483958b7 --- /dev/null +++ b/odk/examples/java/Inspector/InspectorPane.java @@ -0,0 +1,577 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + + +import org.openoffice.XInstanceInspector; + +import com.sun.star.beans.Property; +import com.sun.star.beans.PropertyValue; +import com.sun.star.beans.XIntrospectionAccess; +import com.sun.star.beans.XPropertySet; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.lib.uno.helper.WeakBase; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.Any; +import com.sun.star.uno.AnyConverter; +import com.sun.star.uno.Type; +import com.sun.star.uno.TypeClass; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; + + public class InspectorPane extends WeakBase implements XInstanceInspector{ //, XServiceInfo + private XComponentContext m_xComponentContext; + private XDialogProvider m_xDialogProvider; + private Introspector m_oIntrospector = null; + private SourceCodeGenerator m_oSourceCodeGenerator; + private XTreeControlProvider m_xTreeControlProvider; + private String sTitle = ""; + + + /** The constructor of the inner class has a XMultiServiceFactory parameter. + */ + public InspectorPane(XComponentContext _xComponentContext, XDialogProvider _xDialogProvider, XTreeControlProvider _xTreeControlProvider, int _nLanguage) { + m_xComponentContext = _xComponentContext; + m_xTreeControlProvider = _xTreeControlProvider; + m_xDialogProvider = _xDialogProvider; + m_oIntrospector = Introspector.getIntrospector(m_xComponentContext); + m_oSourceCodeGenerator = new SourceCodeGenerator(_nLanguage); + _xTreeControlProvider.addInspectorPane(this); + } + + /** Inspect the given object for methods, properties, interfaces, and + * services. + * @param _oUserDefinedObject The object to inspect + * @throws RuntimeException If + */ + public void inspect(java.lang.Object _oUserDefinedObject, String _sTitle) throws com.sun.star.uno.RuntimeException { + try { + Object oContainer = m_xTreeControlProvider.inspect(_oUserDefinedObject, _sTitle); + m_xDialogProvider.addInspectorPage(getTitle(), oContainer); + } + catch( Exception exception ) { + exception.printStackTrace(System.err); + }} + + + public void setTitle(String _sTitle){ + if (_sTitle != null){ + if (_sTitle.length() > 0){ + sTitle = _sTitle; + } + } + } + + + public String getTitle(){ + return sTitle; + } + + + + private Type[] getTypes(Object _oUnoObject){ + Type[] aTypes = null; + if (AnyConverter.isArray(_oUnoObject)){ + aTypes = (Type[])_oUnoObject; + } + else{ + aTypes = m_oIntrospector.getInterfaces(_oUnoObject); + } + return aTypes; + } + + + private Object invoke(XUnoMethodNode _oUnoMethodNode){ + try{ + String sParamValueDescription = ""; + Object oUnoReturnObject = _oUnoMethodNode.invoke(); + boolean bHasParameters = _oUnoMethodNode.hasParameters(); + boolean bIsPrimitive = _oUnoMethodNode.isPrimitive(); + if (bHasParameters){ + sParamValueDescription = " (" + m_oSourceCodeGenerator.getMethodParameterValueDescription(_oUnoMethodNode, _oUnoMethodNode.getLastParameterObjects(), true) + ")"; + } + if (oUnoReturnObject != null ){ + String sNodeDescription = ""; + XUnoNode oUnoNode = null; + if (_oUnoMethodNode.getXIdlMethod().getReturnType().getTypeClass().getValue() == TypeClass.VOID_value){ + sNodeDescription += _oUnoMethodNode.getXIdlMethod().getReturnType().getName() + " " + _oUnoMethodNode.getXIdlMethod().getName() + sParamValueDescription; + _oUnoMethodNode.setLabel(sNodeDescription); + m_xTreeControlProvider.nodeChanged(_oUnoMethodNode); + } + else if (bHasParameters || !bIsPrimitive){ + if (bIsPrimitive){ + sNodeDescription += m_oSourceCodeGenerator.getStringValueOfObject(oUnoReturnObject, _oUnoMethodNode.getTypeClass()); + } + else{ + Any aReturnObject = Any.complete(oUnoReturnObject); + String sShortClassName = Introspector.getShortClassName(aReturnObject.getType().getTypeName()); + sNodeDescription += m_oSourceCodeGenerator.getVariableNameforUnoObject(sShortClassName); + } + if (Introspector.isArray(oUnoReturnObject)){ + if (Introspector.isUnoTypeObject(oUnoReturnObject)){ + oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SINTERFACEDESCRIPTION, _oUnoMethodNode.getUnoObject()); + } + else if(Introspector.isUnoPropertyTypeObject(oUnoReturnObject)){ + oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SPROPERTYINFODESCRIPTION, oUnoReturnObject); + } + else if(Introspector.isUnoPropertyValueTypeObject(oUnoReturnObject)){ + oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SPROPERTYVALUEDESCRIPTION, oUnoReturnObject); + } + } + if (oUnoNode == null){ + if (bHasParameters){ + sNodeDescription += sParamValueDescription; + } + oUnoNode = addUnoNode(null, oUnoReturnObject, sNodeDescription); + if (bHasParameters){ + oUnoNode.setParameterObjects(_oUnoMethodNode.getLastParameterObjects()); + } + } + if (oUnoNode != null){ + oUnoNode.setFoldable(!bIsPrimitive); + _oUnoMethodNode.setFoldable(false); + _oUnoMethodNode.addChildNode(oUnoNode); + m_xTreeControlProvider.nodeInserted(_oUnoMethodNode, oUnoNode, _oUnoMethodNode.getChildCount()-1); + } + } + else{ + if (bIsPrimitive){ + sNodeDescription = _oUnoMethodNode.getStandardMethodDescription() + "=" + UnoMethodNode.getDisplayValueOfPrimitiveType(oUnoReturnObject); + _oUnoMethodNode.setLabel(sNodeDescription); + m_xTreeControlProvider.nodeChanged(_oUnoMethodNode); + } + } + } + // ReturnObject of method node == null... + else{ + if (!bHasParameters){ + _oUnoMethodNode.setLabel(_oUnoMethodNode.getLabel() + " = null"); + } + else{ + _oUnoMethodNode.setLabel(_oUnoMethodNode.getXIdlMethod().getName() + sParamValueDescription + " = null"); + } + m_xTreeControlProvider.nodeChanged(_oUnoMethodNode); + } + return oUnoReturnObject; + }catch(Exception exception ) { + return null; + }} + + + public void invokeSelectedMethodNode(){ + XTreePathProvider xTreePathProvider = m_xTreeControlProvider.getSelectedPath(); + XUnoNode oUnoNode = xTreePathProvider.getLastPathComponent(); + if (oUnoNode instanceof XUnoMethodNode){ + invoke((XUnoMethodNode) oUnoNode); + m_xTreeControlProvider.expandPath(xTreePathProvider); + } + } + + + public void addSourceCodeOfSelectedNode(){ + XTreePathProvider oTreePathProvider = m_xTreeControlProvider.getSelectedPath(); + XUnoNode oUnoNode = oTreePathProvider.getLastPathComponent(); + if (oUnoNode instanceof XUnoMethodNode){ + XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode; + if (!oUnoMethodNode.isInvoked() && oUnoMethodNode.isInvokable()){ + invoke(oUnoMethodNode); + } + } + String sSourceCode = m_oSourceCodeGenerator.addSourceCodeOfUnoObject(oTreePathProvider, true, true); + m_xTreeControlProvider.setSourceCode(sSourceCode); + } + + + public void convertCompleteSourceCode(int _nLanguage){ + String sSourceCode = m_oSourceCodeGenerator.convertAllUnoObjects(_nLanguage); + m_xTreeControlProvider.setSourceCode(sSourceCode); + } + + protected XUnoNode getSelectedNode(){ + return m_xTreeControlProvider.getSelectedNode(); + } + + + // add the object to the hashtable for a possible access in the tree + private XUnoFacetteNode addUnoFacetteNode(XUnoNode _oParentNode, String _sNodeDescription, Object _oUnoObject){ + return m_xTreeControlProvider.addUnoFacetteNode( _oParentNode, _sNodeDescription, _oUnoObject); + } + + + private XUnoMethodNode addMethodNode(Object _objectElement, XIdlMethod _xIdlMethod){ + return m_xTreeControlProvider.addMethodNode(_objectElement, _xIdlMethod); + } + + + + private void addMethodsToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoParentObject, XIdlMethod[] _xIdlMethods){ + if (Introspector.isValid(_xIdlMethods)){ + for ( int n = 0; n < _xIdlMethods.length; n++ ) { + XIdlMethod xIdlMethod = _xIdlMethods[n]; + if (!xIdlMethod.getDeclaringClass().getName().equals("com.sun.star.uno.XInterface")){ + XUnoMethodNode oChildNode = addMethodNode(_oUnoParentObject, xIdlMethod); + if (oChildNode != null){ + _oGrandParentNode.addChildNode(oChildNode); + } + } + } + } + } + + + private void addFacetteNodesToTreeNode(XUnoNode _oParentNode, Object _oUnoObject){ + if (m_oIntrospector.hasMethods(_oUnoObject)){ + addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SMETHODDESCRIPTION, _oUnoObject); + } + if (m_oIntrospector.hasProperties(_oUnoObject)){ + addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SPROPERTYDESCRIPTION, _oUnoObject); + } + if (m_oIntrospector.hasInterfaces(_oUnoObject)){ + addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SINTERFACEDESCRIPTION, _oUnoObject); + } + if (m_oIntrospector.isContainer(_oUnoObject)){ + addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SCONTAINERDESCRIPTION, _oUnoObject); + } + if (m_oIntrospector.hasSupportedServices(_oUnoObject)){ + addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SSERVICEDESCRIPTION, _oUnoObject); + } + } + + + private void addInterfacesToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoParentObject, Type[] _aTypes) { + try { + if (_oUnoParentObject != null){ + for ( int m = 0; m < _aTypes.length; m++ ) { + addUnoNode(_oGrandParentNode, _oUnoParentObject, _aTypes[m]); + } + } + } + catch( Exception exception ) { + exception.printStackTrace(System.err); + }} + + + // add all services for the given object to the tree under the node parent + private void addServicesToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoObject) { + try{ + XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _oUnoObject ); + if ( xServiceInfo != null ){ + String[] sSupportedServiceNames = xServiceInfo.getSupportedServiceNames(); + for ( int m = 0; m < sSupportedServiceNames.length; m++ ) { + String sServiceName = sSupportedServiceNames[m]; + if (sServiceName.length() > 0){ + XUnoNode oUnoNode = addUnoNode(_oGrandParentNode, _oUnoObject, sSupportedServiceNames[m]); + oUnoNode.setNodeType(XUnoNode.nSERVICE); + } + } + } + } + catch(Exception exception) { + exception.printStackTrace(System.err); + }} + + + private void addPropertiesAndInterfacesOfService(XUnoNode _oUnoServiceNode){ + String sServiceName = _oUnoServiceNode.getClassName(); + Object oUnoObject = _oUnoServiceNode.getUnoObject(); + addInterfacesToTreeNode(_oUnoServiceNode, oUnoObject, m_oIntrospector.getInterfaces(oUnoObject, sServiceName)); + addPropertiesToTreeNode(_oUnoServiceNode, oUnoObject, m_oIntrospector.getProperties(oUnoObject, sServiceName)); + } + + + private void addPropertiesToTreeNode(XUnoNode _oParentNode, Object _oUnoParentObject, Property[] _aProperties) { + try { + if (_aProperties.length > 0){ + for ( int n = 0; n < _aProperties.length; n++ ){ + Property aProperty = _aProperties[n]; + XIntrospectionAccess xIntrospectionAccess = m_oIntrospector.getXIntrospectionAccess(_oUnoParentObject); + XPropertySet xPropertySet = UnoRuntime.queryInterface( XPropertySet.class, xIntrospectionAccess.queryAdapter(new Type( XPropertySet.class))); + if (xPropertySet != null) { + if (xPropertySet.getPropertySetInfo().hasPropertyByName(aProperty.Name)){ + Object objectElement = xPropertySet.getPropertyValue(aProperty.Name); + if (objectElement != null) { + XUnoNode oChildNode = m_xTreeControlProvider.addUnoPropertyNode(_oUnoParentObject, aProperty, objectElement); + if (oChildNode != null){ + _oParentNode.addChildNode(oChildNode); + } + } + } + } + } + } + } + catch(Exception exception) { + exception.printStackTrace(System.err); + }} + + + private void addContainerElementsToTreeNode(XUnoNode _oParentNode, Object _oUnoParentObject){ + Object[] oUnoContainerElements = m_oIntrospector.getUnoObjectsOfContainer(_oUnoParentObject); + if (Introspector.isValid(oUnoContainerElements)){ + if (oUnoContainerElements.length > 0){ + for (int i=0; i< oUnoContainerElements.length; i++){ + XUnoNode oChildNode = addUnoNode(_oParentNode, oUnoContainerElements[i], UnoNode.getNodeDescription(oUnoContainerElements[i])); + m_xTreeControlProvider.nodeInserted(_oParentNode, oChildNode, _oParentNode.getChildCount()-1); + } + } + } + } + + + private XUnoNode addUnoNode(XUnoNode _oParentNode, Object _oUnoObject, String _sLabel ){ + XUnoNode oUnoNode = this.m_xTreeControlProvider.addUnoNode(_oUnoObject); + oUnoNode.setLabel(_sLabel); + if (_oParentNode != null){ + _oParentNode.addChildNode(oUnoNode); + } + setNodeFoldable(oUnoNode, _oUnoObject); + return oUnoNode; + } + + + private void setNodeFoldable(XUnoNode _oUnoNode, Object _oUnoObject){ + if (_oUnoObject != null){ + if (!Introspector.isObjectPrimitive(_oUnoObject)){ + _oUnoNode.setFoldable(true); + } + } + } + + + private XUnoNode addUnoNode(XUnoNode _oParentNode, Object _oUnoObject, Type _aType){ + XUnoNode oUnoNode = this.m_xTreeControlProvider.addUnoNode(_oUnoObject, _aType); + if (_oParentNode != null){ + _oParentNode.addChildNode(oUnoNode); + } + setNodeFoldable(oUnoNode, _oUnoObject); + return oUnoNode; + } + + + private void addPropertySetInfoNodesToTreeNode(XUnoFacetteNode _oUnoFacetteNode, Object _oUnoObject){ + if (_oUnoObject.getClass().isArray()){ + Object[] object = ( Object[] ) _oUnoObject; + for ( int i = 0; i < object.length; i++ ) { + Property aProperty = (Property) object[i]; + XUnoPropertyNode oUnoPropertyNode = m_xTreeControlProvider.addUnoPropertyNode(_oUnoObject, aProperty); + oUnoPropertyNode.setLabel(XUnoFacetteNode.SPROPERTYINFODESCRIPTION + " (" + aProperty.Name + ")"); + oUnoPropertyNode.setFoldable(true); + _oUnoFacetteNode.addChildNode(oUnoPropertyNode); + } + } + } + + private void addPrimitiveValuesToTreeNode(XUnoNode _oUnoNode, Object _oUnoObject){ + if (_oUnoObject.getClass().isArray()){ + if (!_oUnoObject.getClass().getComponentType().isPrimitive()){ + Object[] object = ( Object[] ) _oUnoObject; + for ( int i = 0; i < object.length; i++ ) { + if (Introspector.isObjectPrimitive(object[i])){ + addUnoNode(_oUnoNode, null, UnoNode.getNodeDescription(object[i])); + } + } + } + else{ + String[] sDisplayValues = UnoNode.getDisplayValuesofPrimitiveArray(_oUnoObject); + for ( int i = 0; i < sDisplayValues.length; i++ ) { + addUnoNode(_oUnoNode, null, sDisplayValues[i]); + } + } + } + } + + + private void addPropertySetInfoSubNodes(XUnoPropertyNode _oUnoPropertyNode){ + Property aProperty = _oUnoPropertyNode.getProperty(); + _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithName(aProperty)); + _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithType(aProperty)); + _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithHandle(aProperty)); + _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithAttributesDescription(aProperty)); + } + + + private void addPropertyValueSubNodes(XUnoFacetteNode _oUnoFacetteNode, Object _oUnoObject){ + if (Introspector.isUnoPropertyValueTypeObject(_oUnoObject)){ + Object[] object = ( Object[] ) _oUnoObject; + for ( int i = 0; i < object.length; i++ ) { + String sObjectClassName = object[i].getClass().getName(); + if (sObjectClassName.equals("com.sun.star.beans.PropertyValue")){ + XUnoNode oChildNode = null; + PropertyValue aPropertyValue = (PropertyValue) object[i]; + if (! Introspector.isObjectPrimitive(aPropertyValue.Value)){ + oChildNode = m_xTreeControlProvider.addUnoPropertyNode(_oUnoObject, aPropertyValue, _oUnoObject); + } + else{ + oChildNode = addUnoNode(null, aPropertyValue.Value, UnoPropertyNode.getStandardPropertyValueDescription(aPropertyValue)); + } + if (oChildNode != null){ + _oUnoFacetteNode.addChildNode(oChildNode); + } + } + } + } + } + + + public boolean expandNode(XUnoNode _oUnoNode){ + if ( _oUnoNode != null ) { + _oUnoNode.setFoldable(false); + if (m_xTreeControlProvider.isMethodNode(_oUnoNode)){ + XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) _oUnoNode; + if (!oUnoMethodNode.isInvoked()){ + Object oUnoReturnObject = invoke((XUnoMethodNode) _oUnoNode); + if (oUnoReturnObject == null){ + _oUnoNode.setFoldable(true); + return false; + } + } + } + else if (m_xTreeControlProvider.isPropertyNode(_oUnoNode)){ + XUnoPropertyNode oUnoPropertyNode = (XUnoPropertyNode) _oUnoNode; + Object oUnoObject = oUnoPropertyNode.getUnoReturnObject(); + if (oUnoPropertyNode.getPropertyNodeType() == XUnoPropertyNode.nPROPERTYSETINFOTYPE){ + addPropertySetInfoSubNodes(oUnoPropertyNode); + } + else{ + //TODO: this code is redundant!!! + if ( oUnoObject.getClass().isArray()){ + // TODO: probably we should provide a possibility to insert also non-primitive nodes + addPrimitiveValuesToTreeNode(oUnoPropertyNode, oUnoObject); + } + else{ + addFacetteNodesToTreeNode(oUnoPropertyNode, oUnoObject); + } + } + } + else if (m_xTreeControlProvider.isFacetteNode(_oUnoNode)){ + XUnoFacetteNode oUnoFacetteNode = (XUnoFacetteNode) _oUnoNode; + Object oUnoObject = _oUnoNode.getUnoObject(); + if (oUnoFacetteNode.isMethodNode()){ + addMethodsToTreeNode(oUnoFacetteNode, oUnoObject, m_oIntrospector.getMethods(oUnoObject)); + } + if (oUnoFacetteNode.isPropertyNode()){ + String sNodeDescription = oUnoFacetteNode.getLabel(); + // TODO: it's very dangerous to distinguish the different UnoFacetteNodes only by the node description + if (sNodeDescription.startsWith(XUnoFacetteNode.SPROPERTYINFODESCRIPTION)){ + addPropertySetInfoNodesToTreeNode(oUnoFacetteNode, oUnoObject); + } + else if (sNodeDescription.startsWith(XUnoFacetteNode.SPROPERTYVALUEDESCRIPTION)){ + addPropertyValueSubNodes(oUnoFacetteNode, oUnoObject); + } + else{ + addPropertiesToTreeNode(oUnoFacetteNode, oUnoObject, m_oIntrospector.getProperties(oUnoObject)); + } + } + if (oUnoFacetteNode.isServiceNode()){ + addServicesToTreeNode(oUnoFacetteNode, oUnoObject); + } + if (oUnoFacetteNode.isInterfaceNode()){ + addInterfacesToTreeNode(oUnoFacetteNode, oUnoObject, getTypes(oUnoObject)); + } + if (oUnoFacetteNode.isContainerNode()){ + addContainerElementsToTreeNode(oUnoFacetteNode, oUnoObject); + } + } + else if (_oUnoNode.getNodeType() == XUnoNode.nSERVICE){ + addPropertiesAndInterfacesOfService(_oUnoNode); + } + else if (_oUnoNode.getNodeType() == XUnoNode.nINTERFACE){ + Type aType = _oUnoNode.getUnoType(); + if (aType != null){ + addMethodsToTreeNode(_oUnoNode, _oUnoNode.getUnoObject(), m_oIntrospector.getMethodsOfInterface(aType)); + } + } + else if (_oUnoNode.getNodeType() == XUnoNode.nOTHERS){ + Object oUnoObject = _oUnoNode.getUnoObject(); + if ( oUnoObject.getClass().isArray()){ + // TODO: probably we should provide a possibility to insert also non-primitive nodes + addPrimitiveValuesToTreeNode(_oUnoNode, oUnoObject); + } + else{ + addFacetteNodesToTreeNode(_oUnoNode, oUnoObject); + } + } + } + return true; + } + + + + public void applyFilter(XUnoFacetteNode _oUnoFacetteNode, String _sFilter){ + for (int i = 0; i < _oUnoFacetteNode.getChildCount(); i++){ + XUnoNode oUnoNode = _oUnoFacetteNode.getChild(i); + boolean bIsVisible = oUnoNode.isFilterApplicable(_sFilter); + m_xTreeControlProvider.setNodeVisible(oUnoNode, bIsVisible); + } + _oUnoFacetteNode.setFilter(_sFilter); + } + + + public String getFilter(XUnoNode _oUnoNode){ + String sFilter = ""; + if (_oUnoNode != null){ + XUnoNode oUnoNode = _oUnoNode; + boolean bleaveLoop = false; + do{ + if (m_xTreeControlProvider.isFacetteNode(oUnoNode)){ + sFilter = ((XUnoFacetteNode) oUnoNode).getFilter(); + bleaveLoop = true; + } + else{ + if (oUnoNode.getParentNode() != null){ + oUnoNode = oUnoNode.getParentNode(); + } + else{ + bleaveLoop = true; + } + } + } while(!bleaveLoop); + } + return sFilter; + } + + + public void showPopUpMenu(Object _invoker, int x, int y) throws ClassCastException{ + XUnoNode oUnoNode = getSelectedNode(); + boolean bdoEnableInvoke = oUnoNode instanceof XUnoMethodNode; + if (bdoEnableInvoke){ + XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode; + bdoEnableInvoke = oUnoMethodNode.isInvokable(); + } + m_xDialogProvider.enablePopupMenuItem(XDialogProvider.SINVOKE, bdoEnableInvoke); + m_xDialogProvider.showPopUpMenu(_invoker, x, y); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/InstanceInspector.idl b/odk/examples/java/Inspector/InstanceInspector.idl new file mode 100644 index 000000000..81b396170 --- /dev/null +++ b/odk/examples/java/Inspector/InstanceInspector.idl @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +#ifndef INCLUDED_ORG_OPENOFFICE_INSTANCEINSPECTOR_IDL +#define INCLUDED_ORG_OPENOFFICE_INSTANCEINSPECTOR_IDL + +#include <XInstanceInspector.idl> + + +module org { module openoffice { + + /** + * This service describes an instance inspector which can inspect + * UNO objects and provides information about the implemented + * interfaces, the supported services and properties of this object. + */ + service InstanceInspector: XInstanceInspector; + +}; }; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/InstanceInspectorTest.odt b/odk/examples/java/Inspector/InstanceInspectorTest.odt Binary files differnew file mode 100644 index 000000000..74cde4e68 --- /dev/null +++ b/odk/examples/java/Inspector/InstanceInspectorTest.odt diff --git a/odk/examples/java/Inspector/Introspector.java b/odk/examples/java/Inspector/Introspector.java new file mode 100644 index 000000000..b8d3be3c0 --- /dev/null +++ b/odk/examples/java/Inspector/Introspector.java @@ -0,0 +1,643 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import java.util.ArrayList; +import java.util.List; + +import com.sun.star.beans.IllegalTypeException; +import com.sun.star.beans.MethodConcept; +import com.sun.star.beans.Property; +import com.sun.star.beans.XIntrospection; +import com.sun.star.beans.XIntrospectionAccess; +import com.sun.star.container.XEnumeration; +import com.sun.star.container.XEnumerationAccess; +import com.sun.star.container.XHierarchicalNameAccess; +import com.sun.star.container.XIndexAccess; +import com.sun.star.lang.XMultiComponentFactory; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.lang.XTypeProvider; +import com.sun.star.lib.uno.helper.WeakBase; +import com.sun.star.reflection.TypeDescriptionSearchDepth; +import com.sun.star.reflection.XConstantTypeDescription; +import com.sun.star.reflection.XConstantsTypeDescription; +import com.sun.star.reflection.XIdlClass; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.reflection.XIdlReflection; +import com.sun.star.reflection.XIndirectTypeDescription; +import com.sun.star.reflection.XInterfaceTypeDescription; +import com.sun.star.reflection.XPropertyTypeDescription; +import com.sun.star.reflection.XServiceTypeDescription; +import com.sun.star.reflection.XTypeDescription; +import com.sun.star.reflection.XTypeDescriptionEnumeration; +import com.sun.star.reflection.XTypeDescriptionEnumerationAccess; +import com.sun.star.ucb.XSimpleFileAccess; +import com.sun.star.uno.AnyConverter; +import com.sun.star.uno.Type; +import com.sun.star.uno.TypeClass; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; + +public class Introspector extends WeakBase{ + + private XIntrospection m_xIntrospection; + private XMultiComponentFactory m_xMultiComponentFactory; + private XComponentContext m_xComponentContext; + private XTypeDescriptionEnumerationAccess m_xTDEnumerationAccess; + private XIdlReflection mxIdlReflection; + private static Introspector m_oIntrospector = null; + private XSimpleFileAccess xSimpleFileAccess = null; + + + + public static Introspector getIntrospector(){ + if (m_oIntrospector == null){ + throw new NullPointerException(); + } + else{ + return m_oIntrospector; + } + } + + public static Introspector getIntrospector(XComponentContext _xComponentContext){ + if (m_oIntrospector == null){ + m_oIntrospector = new Introspector(_xComponentContext); + } + return m_oIntrospector; + } + + + /** Creates a new instance of Introspection */ + private Introspector(XComponentContext _xComponentContext) { + try{ + m_xComponentContext = _xComponentContext; + m_xMultiComponentFactory = m_xComponentContext.getServiceManager(); + Object o = m_xMultiComponentFactory.createInstanceWithContext("com.sun.star.beans.Introspection", m_xComponentContext); + m_xIntrospection = UnoRuntime.queryInterface(XIntrospection.class, o ); + Object oCoreReflection = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.reflection.CoreReflection", getXComponentContext()); + mxIdlReflection = UnoRuntime.queryInterface(XIdlReflection.class, oCoreReflection); + initTypeDescriptionManager(); + } + catch( Exception exception ) { + System.err.println( exception ); + }} + + + protected XComponentContext getXComponentContext(){ + return m_xComponentContext; + } + + + private XMultiComponentFactory getXMultiComponentFactory(){ + return m_xMultiComponentFactory; + } + + + protected XIntrospectionAccess getXIntrospectionAccess(Object _oUnoComponent){ + return m_xIntrospection.inspect(_oUnoComponent); + } + + + public boolean isContainer(Object _oUnoObject){ + boolean bIsContainer = false; + try { + XIntrospectionAccess xIntrospectionAccessObject = getXIntrospectionAccess(_oUnoObject); + if (xIntrospectionAccessObject != null){ + XEnumerationAccess xEnumerationAccess = UnoRuntime.queryInterface(XEnumerationAccess.class, xIntrospectionAccessObject.queryAdapter( new Type( XEnumerationAccess.class ) ) ); + if (xEnumerationAccess != null){ + XEnumeration xEnumeration = xEnumerationAccess.createEnumeration(); + bIsContainer = xEnumeration.hasMoreElements(); + } + if (!bIsContainer){ + XIndexAccess xIndexAccess = UnoRuntime.queryInterface( XIndexAccess.class, xIntrospectionAccessObject.queryAdapter(new Type( XIndexAccess.class ))); + if (xIndexAccess != null){ + bIsContainer = (xIndexAccess.getCount() > 0); + } + } + } + } catch (IllegalTypeException ex) { + ex.printStackTrace(System.err); + } + return bIsContainer; + } + + + // add all containers for the given object to the tree under the node + // parent + public Object[] getUnoObjectsOfContainer(Object _oUnoParentObject) { + Object[] oRetComponents = null; + try { + ArrayList<Object> oRetComponentsVector = new ArrayList<Object>(); + XIntrospectionAccess xIntrospectionAccessObject = getXIntrospectionAccess(_oUnoParentObject); + if ( xIntrospectionAccessObject != null ) { + XEnumerationAccess xEnumerationAccess = UnoRuntime.queryInterface(XEnumerationAccess.class, xIntrospectionAccessObject.queryAdapter( new Type( XEnumerationAccess.class ) ) ); + if ( xEnumerationAccess != null ) { + XEnumeration xEnumeration = xEnumerationAccess.createEnumeration(); + while ( xEnumeration.hasMoreElements() ) { + oRetComponentsVector.add(xEnumeration.nextElement()); + } + } + XIndexAccess xIndexAccess = UnoRuntime.queryInterface( XIndexAccess.class, xIntrospectionAccessObject.queryAdapter(new Type( XIndexAccess.class ))); + if ( xIndexAccess != null ) { + XIdlMethod mMethod = xIntrospectionAccessObject.getMethod("getByIndex", com.sun.star.beans.MethodConcept.INDEXCONTAINER); + for ( int i = 0; i < xIndexAccess.getCount(); i++ ) { + Object[][] aParamInfo = new Object[1][1]; + aParamInfo[0] = new Integer[] { Integer.valueOf(i) }; + oRetComponentsVector.add(mMethod.invoke(_oUnoParentObject, aParamInfo)); + } + } + } + if (oRetComponentsVector != null){ + oRetComponents = new Object[oRetComponentsVector.size()]; + oRetComponentsVector.toArray(oRetComponents); + } + } + catch( Exception exception ) { + System.err.println( exception ); + } + return oRetComponents; + } + + + protected XIdlMethod[] getMethodsOfInterface(Type _aType){ + try{ + XIdlClass xIdlClass = mxIdlReflection.forName(_aType.getTypeName()); + return xIdlClass.getMethods(); + } + catch( Exception e ) { + System.err.println( e ); + return null; + }} + + + + + + public boolean hasMethods(Object _oUnoObject){ + boolean bHasMethods = (getMethods(_oUnoObject).length > 0); + return bHasMethods; + } + + + // add all methods for the given object to the tree under the node parent + public XIdlMethod[] getMethods(Object _oUnoParentObject) { + try { + XIntrospectionAccess xIntrospectionAccess = getXIntrospectionAccess(_oUnoParentObject); + if (xIntrospectionAccess != null){ + XIdlMethod[] xIdlMethods = xIntrospectionAccess.getMethods(MethodConcept.ALL - MethodConcept.DANGEROUS); + return xIdlMethods; + } + } + catch( Exception e ) { + System.err.println( e ); + } + return null; + } + + + public boolean hasProperties(Object _oUnoObject){ + boolean bHasProperties = (getProperties(_oUnoObject).length > 0); + return bHasProperties; + } + + + protected Property[] getProperties( Object _oUnoParentObject){ + try { + XIntrospectionAccess xIntrospectionAccess = getXIntrospectionAccess(_oUnoParentObject); + if (xIntrospectionAccess != null){ + Property[] aProperties = xIntrospectionAccess.getProperties(com.sun.star.beans.PropertyConcept.ATTRIBUTES + com.sun.star.beans.PropertyConcept.PROPERTYSET); + return aProperties; + } + } + catch( Exception e ) { + System.err.println( e ); + } + return null; + } + + + protected Property[] getProperties(Object _oUnoObject, String _sServiceName){ + Property[] aProperties = getProperties(_oUnoObject); + List<Property> aListOfProperties = java.util.Arrays.asList(aProperties); + ArrayList<Property> aPropertiesVector = new ArrayList<Property>(aListOfProperties); + if (aProperties != null){ + XPropertyTypeDescription[] xPropertyTypeDescriptions = getPropertyDescriptionsOfService(_sServiceName); + for (int i = aProperties.length - 1; i >= 0; i--){ + if (!hasByName(xPropertyTypeDescriptions, _sServiceName + "." + aProperties[i].Name)){ + aPropertiesVector.remove(i); + } + } + } + Property[] aRetProperties = new Property[aPropertiesVector.size()]; + aPropertiesVector.toArray(aRetProperties); + return aRetProperties; + } + + + protected Type[] getInterfaces(Object _oUnoObject, String _sServiceName){ + Type[] aTypes = getInterfaces(_oUnoObject); + List<Type> aListOfTypes = java.util.Arrays.asList(aTypes); + ArrayList<Type> aTypesVector = new ArrayList<Type>(aListOfTypes); + if (aTypes != null){ + XInterfaceTypeDescription[] xInterfaceTypeDescriptions = getInterfaceDescriptionsOfService(_sServiceName); + for (int i = aTypes.length - 1; i >= 0; i--){ + if (!hasByName(xInterfaceTypeDescriptions, aTypes[i].getTypeName())){ + aTypesVector.remove(i); + } + } + } + Type[] aRetTypes = new Type[aTypesVector.size()]; + aTypesVector.toArray(aRetTypes); + return aRetTypes; + } + + + public boolean hasInterfaces(Object _oUnoObject){ + return (getInterfaces(_oUnoObject).length > 0); + } + + + protected Type[] getInterfaces(Object _oUnoParentObject){ + Type[] aTypes = new Type[]{}; + XTypeProvider xTypeProvider = UnoRuntime.queryInterface( XTypeProvider.class, _oUnoParentObject); + if ( xTypeProvider != null ) { + aTypes = xTypeProvider.getTypes(); + } + return aTypes; + } + + + + public static boolean isObjectSequence(Object _oUnoObject){ + Type aType = AnyConverter.getType(_oUnoObject); + return aType.getTypeClass().getValue() == TypeClass.SEQUENCE_value; + } + + + public static boolean isObjectPrimitive(Object _oUnoObject){ + boolean breturn = false; + if (_oUnoObject != null){ + Type aType = AnyConverter.getType(_oUnoObject); + breturn = isObjectPrimitive(_oUnoObject.getClass(), aType.getTypeClass()); + } + return breturn; + } + + + public static boolean isPrimitive(TypeClass _typeClass){ + return (( _typeClass == TypeClass.BOOLEAN ) + || ( _typeClass == TypeClass.BYTE ) + || ( _typeClass == TypeClass.CHAR ) + || ( _typeClass == TypeClass.DOUBLE ) + || ( _typeClass == TypeClass.ENUM ) + || ( _typeClass == TypeClass.FLOAT ) + || ( _typeClass == TypeClass.HYPER ) + || ( _typeClass == TypeClass.LONG ) + || ( _typeClass == TypeClass.SHORT ) + || ( _typeClass == TypeClass.STRING ) + || ( _typeClass == TypeClass.UNSIGNED_HYPER ) + || ( _typeClass == TypeClass.UNSIGNED_LONG ) + || ( _typeClass == TypeClass.UNSIGNED_SHORT )); + } + + public static boolean isObjectPrimitive(Class<? extends Object> _oUnoClass, TypeClass _typeClass){ + return !( ( !_oUnoClass.isPrimitive() ) && ( _typeClass != TypeClass.ARRAY ) + && ( _typeClass != TypeClass.BOOLEAN ) + && ( _typeClass != TypeClass.BYTE ) + && ( _typeClass != TypeClass.CHAR ) + && ( _typeClass != TypeClass.DOUBLE ) + && ( _typeClass != TypeClass.ENUM ) + && ( _typeClass != TypeClass.FLOAT ) + && ( _typeClass != TypeClass.HYPER ) + && ( _typeClass != TypeClass.LONG ) + && ( _typeClass != TypeClass.SHORT ) + && ( _typeClass != TypeClass.STRING ) + && ( _typeClass != TypeClass.UNSIGNED_HYPER ) + && ( _typeClass != TypeClass.UNSIGNED_LONG ) + && ( _typeClass != TypeClass.UNSIGNED_SHORT )); + } + + + private void initTypeDescriptionManager() { + try { + Object oTypeDescriptionManager = getXComponentContext().getValueByName("/singletons/com.sun.star.reflection.theTypeDescriptionManager"); + m_xTDEnumerationAccess = UnoRuntime.queryInterface(XTypeDescriptionEnumerationAccess.class, oTypeDescriptionManager); + } catch ( java.lang.Exception e) { + System.out.println(System.out); + }} + + + private XTypeDescriptionEnumerationAccess getXTypeDescriptionEnumerationAccess(){ + return m_xTDEnumerationAccess; + } + + + protected XConstantTypeDescription[] getFieldsOfConstantGroup(String _sTypeClass){ + XConstantTypeDescription[] xConstantTypeDescriptions = null; + try { + TypeClass[] eTypeClasses = new com.sun.star.uno.TypeClass[1]; + eTypeClasses[0] = com.sun.star.uno.TypeClass.CONSTANTS; + XTypeDescriptionEnumeration xTDEnumeration = m_xTDEnumerationAccess.createTypeDescriptionEnumeration(getModuleName(_sTypeClass), eTypeClasses, TypeDescriptionSearchDepth.INFINITE); + while (xTDEnumeration.hasMoreElements()) { + XTypeDescription xTD = xTDEnumeration.nextTypeDescription(); + if (xTD.getName().equals(_sTypeClass)){ + XConstantsTypeDescription xConstantsTypeDescription = UnoRuntime.queryInterface(XConstantsTypeDescription.class, xTD); + xConstantTypeDescriptions = xConstantsTypeDescription.getConstants(); + } + String sName = xTD.getName(); + } + return xConstantTypeDescriptions; + } catch ( java.lang.Exception e) { + System.out.println(System.out); + } + return null; + } + + private XServiceTypeDescription getServiceTypeDescription(String _sServiceName, TypeClass _eTypeClass){ + try{ + if (_sServiceName.length() > 0){ + TypeClass[] eTypeClasses = new com.sun.star.uno.TypeClass[2]; + eTypeClasses[0] = com.sun.star.uno.TypeClass.SERVICE; + eTypeClasses[1] = _eTypeClass; + XTypeDescriptionEnumeration xTDEnumeration = getXTypeDescriptionEnumerationAccess().createTypeDescriptionEnumeration(Introspector.getModuleName(_sServiceName), eTypeClasses, TypeDescriptionSearchDepth.INFINITE); + while (xTDEnumeration.hasMoreElements()) { + XTypeDescription xTD = xTDEnumeration.nextTypeDescription(); + if (xTD.getName().equals(_sServiceName)){ + XServiceTypeDescription xServiceTypeDescription = UnoRuntime.queryInterface(XServiceTypeDescription.class, xTD); + return xServiceTypeDescription; + } + } + } + return null; + } catch (Exception ex) { + ex.printStackTrace(System.err); + return null; + }} + + + public XPropertyTypeDescription[] getPropertyDescriptionsOfService(String _sServiceName){ + try { + XServiceTypeDescription xServiceTypeDescription = getServiceTypeDescription(_sServiceName, com.sun.star.uno.TypeClass.PROPERTY); + if (xServiceTypeDescription != null){ + XPropertyTypeDescription[] xPropertyTypeDescriptions = xServiceTypeDescription.getProperties(); + return xPropertyTypeDescriptions; + } + } catch ( java.lang.Exception e) { + System.out.println(System.out); + } + return new XPropertyTypeDescription[]{}; + } + + + public XTypeDescription getReferencedType(String _sTypeName){ + XTypeDescription xTypeDescription = null; + try{ + XHierarchicalNameAccess xHierarchicalNameAccess = UnoRuntime.queryInterface(XHierarchicalNameAccess.class, m_xTDEnumerationAccess); + if (xHierarchicalNameAccess != null){ + if (xHierarchicalNameAccess.hasByHierarchicalName(_sTypeName)){ + XIndirectTypeDescription xIndirectTypeDescription = UnoRuntime.queryInterface(XIndirectTypeDescription.class, xHierarchicalNameAccess.getByHierarchicalName(_sTypeName)); + if (xIndirectTypeDescription != null){ + xTypeDescription = xIndirectTypeDescription.getReferencedType(); + } + } + } + } catch (Exception ex) { + ex.printStackTrace(System.err); + } + return xTypeDescription; + } + + + private XInterfaceTypeDescription[] getInterfaceDescriptionsOfService(String _sServiceName){ + try { + XServiceTypeDescription xServiceTypeDescription = getServiceTypeDescription(_sServiceName, com.sun.star.uno.TypeClass.INTERFACE); + if (xServiceTypeDescription != null){ + XInterfaceTypeDescription[] xInterfaceTypeDescriptions = xServiceTypeDescription.getMandatoryInterfaces(); + return xInterfaceTypeDescriptions; + } + } catch ( java.lang.Exception e) { + System.out.println(System.out); + } + return new XInterfaceTypeDescription[]{}; + } + + + private static boolean hasByName(XTypeDescription[] _xTypeDescriptions, String _sTypeName){ + for (int i = 0; i < _xTypeDescriptions.length; i++){ + if (_xTypeDescriptions[i].getName().equals(_sTypeName)){ + return true; + } + } + return false; + } + + + public static String getModuleName(String _sTypeClass){ + int nlastindex = _sTypeClass.lastIndexOf("."); + if (nlastindex > -1){ + return _sTypeClass.substring(0, nlastindex); + } + else{ + return ""; + } + } + + + public static String getShortClassName(String _sClassName){ + String sShortClassName = _sClassName; + int nindex = _sClassName.lastIndexOf("."); + if ((nindex < _sClassName.length()) && nindex > -1){ + sShortClassName = _sClassName.substring(nindex + 1); + } + return sShortClassName; + } + + + + public static boolean isUnoTypeObject(Object _oUnoObject){ + return isOfUnoType(_oUnoObject, "com.sun.star.uno.Type"); + } + + + public static boolean isUnoPropertyTypeObject(Object _oUnoObject){ + return isOfUnoType(_oUnoObject, "com.sun.star.beans.Property"); + } + + + public static boolean isUnoPropertyValueTypeObject(Object _oUnoObject){ + return isOfUnoType(_oUnoObject, "com.sun.star.beans.PropertyValue"); + } + + + private static boolean isOfUnoType(Object _oUnoObject, String _sTypeName){ + boolean bIsUnoObject = false; + if (_oUnoObject != null){ + if (_oUnoObject.getClass().isArray()){ + if (!_oUnoObject.getClass().getComponentType().isPrimitive()){ + Object[] oUnoArray = (Object[]) _oUnoObject; + if (oUnoArray.length > 0){ + bIsUnoObject = ( oUnoArray[0].getClass().getName().equals(_sTypeName)); + } + } + } + } + else{ + bIsUnoObject = (_oUnoObject.getClass().getName().equals(_sTypeName)); + } + return bIsUnoObject; + } + + + public String getConstantDisplayString(int _nValue, XConstantTypeDescription[] _xConstantTypeDescription, String _sDisplayString){ + String sPrefix = ""; + int[] nbits = new int[_xConstantTypeDescription.length]; + for (int i = 0; i < _xConstantTypeDescription.length; i++){ + short nConstantValue = ((Short) _xConstantTypeDescription[i].getConstantValue()).shortValue(); + nbits[i] = _nValue & nConstantValue; + if (nbits[i] > 0){ + _sDisplayString += sPrefix + _xConstantTypeDescription[i].getName(); + sPrefix = " + "; + } + } + return _sDisplayString; + } + + + public static boolean isValid(Object[] _oObject){ + if (_oObject != null){ + if (_oObject.length > 0){ + return true; + } + } + return false; + } + + + + + + public static boolean isArray(Object _oObject){ + return _oObject.getClass().isArray(); + } + + + public boolean hasSupportedServices(Object _oUnoObject){ + boolean bHasSupportedServices = false; + XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _oUnoObject); + if ( xServiceInfo != null ){ + String[] sSupportedServiceNames = xServiceInfo.getSupportedServiceNames(); + bHasSupportedServices = sSupportedServiceNames.length > 0; + } + return bHasSupportedServices; + } + + + public Object getValueOfText(TypeClass aTypeClass, String sText){ + Object oReturn = null; + switch (aTypeClass.getValue()){ + case TypeClass.CHAR_value: + break; + case TypeClass.DOUBLE_value: + oReturn = Double.valueOf(sText); + break; + case TypeClass.ENUM_value: + break; + case TypeClass.FLOAT_value: + oReturn = Float.valueOf(sText); + break; + case TypeClass.HYPER_value: + oReturn = Long.valueOf(sText); + break; + case TypeClass.LONG_value: + oReturn = Integer.valueOf(sText); + break; + case TypeClass.SHORT_value: + oReturn = Byte.valueOf(sText); + break; + case TypeClass.STRING_value: + oReturn = sText; + break; + case TypeClass.UNSIGNED_HYPER_value: + oReturn = Long.valueOf(sText); + break; + case TypeClass.UNSIGNED_LONG_value: + oReturn = Integer.valueOf(sText); + break; + case TypeClass.UNSIGNED_SHORT_value: + oReturn = Byte.valueOf(sText); + break; + default: + } + return oReturn; + } + + + public XSimpleFileAccess getXSimpleFileAccess(){ + try { + if (xSimpleFileAccess == null){ + Object oSimpleFileAccess = m_xComponentContext.getServiceManager().createInstanceWithContext("com.sun.star.ucb.SimpleFileAccess", m_xComponentContext); + xSimpleFileAccess = com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, oSimpleFileAccess); + } + return xSimpleFileAccess; + } catch (com.sun.star.uno.Exception ex) { + ex.printStackTrace(System.err); + return null; + }} + + + public boolean isValidSDKInstallationPath(String _sSDKInstallationPath){ + boolean bIsValid = false; + try { + String sIDLFolder = Introspector.addToPath(_sSDKInstallationPath, Inspector.sIDLDOCUMENTSUBFOLDER); + String sIndexFile = Introspector.addToPath(_sSDKInstallationPath, "index.html"); + if (getXSimpleFileAccess() != null){ + bIsValid = (getXSimpleFileAccess().exists(sIDLFolder) && getXSimpleFileAccess().exists(sIndexFile)); + } + } catch (com.sun.star.uno.Exception ex) { + ex.printStackTrace(System.err); + } + return bIsValid; + } + + + public static String addToPath(String _sPath, String _sSubPath){ + if (!_sPath.endsWith("/")){ + _sPath += "/"; + } + return _sPath + _sSubPath; + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/Makefile b/odk/examples/java/Inspector/Makefile new file mode 100644 index 000000000..a0d80bf6d --- /dev/null +++ b/odk/examples/java/Inspector/Makefile @@ -0,0 +1,194 @@ +#************************************************************************* +# +# The Contents of this file are made available subject to the terms of +# the BSD license. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. Neither the name of Sun Microsystems, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#************************************************************************** + +# Builds the Java InstanceInspector component example of the SDK. + +PRJ=../../.. +SETTINGS=$(PRJ)/settings + +include $(SETTINGS)/settings.mk +include $(SETTINGS)/std.mk + +# Define non-platform/compiler specific settings + +# we use the sample directory name for separating this example +# from others in the output directory +SAMPLE_NAME=InstanceInspector +SAMPLE_CLASS_OUT=$(OUT_CLASS)/$(SAMPLE_NAME) +SAMPLE_GEN_OUT=$(OUT_MISC)/$(SAMPLE_NAME) + +# some special macro names for separating the component jar stuff +COMP_NAME=Inspector +COMP_CLASS_OUT=$(SAMPLE_CLASS_OUT)/$(COMP_NAME) +COMP_GEN_OUT=$(SAMPLE_GEN_OUT)/$(COMP_NAME) +COMP_RDB_NAME=$(COMP_NAME).uno.rdb +COMP_RDB=$(COMP_GEN_OUT)/$(COMP_RDB_NAME) +COMP_PACKAGE=$(OUT_BIN)/$(COMP_NAME).$(UNOOXT_EXT) +COMP_PACKAGE_URL=$(subst \\,\,"$(COMP_PACKAGE_DIR)$(PS)$(COMP_NAME).$(UNOOXT_EXT)") +COMP_JAR_NAME=$(COMP_NAME).uno.jar +COMP_JAR=$(SAMPLE_CLASS_OUT)/$(COMP_JAR_NAME) +COMP_JAR_MANIFEST=$(COMP_GEN_OUT)/$(COMP_NAME).uno.Manifest +COMP_UNOPKG_MANIFEST = $(COMP_GEN_OUT)/META-INF/manifest.xml +COMP_REGISTERFLAG=$(COMP_GEN_OUT)$(PS)java_$(COMP_NAME)_register_component.flag + +IDLFILES = InstanceInspector.idl \ + XInstanceInspector.idl + +# normally the idl file should be stored in a directory tree fitting the +# module structure, for the example we know the module structure +PACKAGE = org/openoffice + +COMP_JAVAFILES = XDialogProvider.java XTreeControlProvider.java XTreePathProvider.java MethodParametersDialog.java HideableMutableTreeNode.java HideableTreeModel.java Introspector.java XUnoNode.java SwingUnoNode.java UnoNode.java XUnoMethodNode.java SwingUnoMethodNode.java UnoMethodNode.java XUnoPropertyNode.java SwingUnoPropertyNode.java UnoPropertyNode.java XUnoFacetteNode.java SwingUnoFacetteNode.java TDocSupplier.java UnoTreeRenderer.java InspectorAddon.java XLanguageSourceCodeGenerator.java SourceCodeGenerator.java InspectorPane.java SwingDialogProvider.java SwingTreeControlProvider.java SwingTreePathProvider.java Inspector.java +COMP_CLASSFILES = $(patsubst %.java,$(COMP_CLASS_OUT)/%.class,$(COMP_JAVAFILES)) + +GEN_CLASSFILES = $(patsubst %.idl,$(SAMPLE_CLASS_OUT)/$(PACKAGE)/%.class,$(IDLFILES)) +GEN_TYPELIST = $(subst /,.,$(patsubst %.idl,-T$(PACKAGE)/% ,$(IDLFILES))) +GEN_URDFILES = $(patsubst %.idl,$(SAMPLE_GEN_OUT)/%.urd,$(IDLFILES)) + +# the generated types are necessary for the component jar +GEN_CLASSFILENAMES = $(subst $(SAMPLE_CLASS_OUT)/,,$(GEN_CLASSFILES)) + +SDK_CLASSPATH = $(subst $(EMPTYSTRING) $(PATH_SEPARATOR),$(PATH_SEPARATOR),$(CLASSPATH)\ + $(PATH_SEPARATOR)$(SAMPLE_CLASS_OUT)\ + $(PATH_SEPARATOR)$(COMP_CLASS_OUT)) + +COMP_IMAGE_FILES= images/containers_16.png \ + images/content_16.png \ + images/interfaces_16.png \ + images/methods_16.png \ + images/properties_16.png \ + images/services_16.png + +# Targets +.PHONY: ALL +ALL : JavaInspectorExample + +include $(SETTINGS)/stdtarget.mk + +# rule for component manifest file +$(COMP_GEN_OUT)/%.Manifest : + -$(MKDIR) $(subst /,$(PS),$(@D)) + @echo RegistrationClassName: $(basename $(basename $(@F)))> $@ + +# rule for compiling the IDL files +$(SAMPLE_GEN_OUT)/%.urd : %.idl + -$(MKDIR) $(subst /,$(PS),$(@D)) + $(IDLC) -C -I. -I$(IDL_DIR) -O$(SAMPLE_GEN_OUT) $< + +# rule for creating the component rdb file +$(COMP_GEN_OUT)/%.rdb : $(GEN_URDFILES) + -$(DEL) $(subst \\,\,$(subst /,$(PS),$@)) + -$(MKDIR) $(subst /,$(PS),$(@D)) + $(REGMERGE) $@ /UCR $(GEN_URDFILES) + +# rule for creating IDL dependent class files +$(GEN_CLASSFILES) : $(COMP_RDB) + -$(MKDIR) $(subst /,$(PS),$(@D)) + $(JAVAMAKER) -nD $(GEN_TYPELIST) -O$(SAMPLE_CLASS_OUT) $(COMP_RDB) -X$(URE_TYPES) -X$(OFFICE_TYPES) + +# component as well as application are dependent from the generated types +# rule for component class files +$(COMP_CLASS_OUT)/%.class : %.java $(GEN_CLASSFILES) + -$(MKDIR) $(subst /,$(PS),$(@D)) + $(SDK_JAVAC) $(JAVAC_FLAGS) -classpath "$(SDK_CLASSPATH)" -sourcepath . -d $(COMP_CLASS_OUT) $< + +# rule for component jar file +$(COMP_JAR) : $(COMP_JAR_MANIFEST) $(COMP_CLASSFILES) $(COMP_IMAGE_FILES) + -$(DEL) $(subst \\,\,$(subst /,$(PS),$@)) + -$(MKDIR) $(subst /,$(PS),$(@D)) + $(SDK_JAR) cvfm $@ $< -C $(COMP_CLASS_OUT) . + +cd $(subst /,$(PS),$(SAMPLE_CLASS_OUT)) && $(SDK_JAR) uvf $(@F) $(GEN_CLASSFILENAMES) + +$(SDK_JAR) uvf $@ $(COMP_IMAGE_FILES) + +# rule for component package manifest +$(COMP_GEN_OUT)/%/manifest.xml : + -$(MKDIR) $(subst /,$(PS),$(@D)) + @echo $(OSEP)?xml version="$(QM)1.0$(QM)" encoding="$(QM)UTF-8$(QM)"?$(CSEP) > $@ + @echo $(OSEP)!DOCTYPE manifest:manifest PUBLIC "$(QM)-//OpenOffice.org//DTD Manifest 1.0//EN$(QM)" "$(QM)Manifest.dtd$(QM)"$(CSEP) >> $@ + @echo $(OSEP)manifest:manifest xmlns:manifest="$(QM)http://openoffice.org/2001/manifest$(QM)"$(CSEP) >> $@ + @echo $(SQM) $(SQM)$(OSEP)manifest:file-entry manifest:media-type="$(QM)application/vnd.sun.star.configuration-data$(QM)" >> $@ + @echo $(SQM) $(SQM)manifest:full-path="$(QM)Addons.xcu$(QM)"/$(CSEP) >> $@ + @echo $(SQM) $(SQM)$(OSEP)manifest:file-entry manifest:media-type="$(QM)application/vnd.sun.star.configuration-data$(QM)" >> $@ + @echo $(SQM) $(SQM)manifest:full-path="$(QM)ProtocolHandler.xcu$(QM)"/$(CSEP) >> $@ + @echo $(SQM) $(SQM)$(OSEP)manifest:file-entry manifest:media-type="$(QM)application/vnd.sun.star.configuration-schema$(QM)" >> $@ + @echo $(SQM) $(SQM)manifest:full-path="$(QM)ObjectInspector.xcs$(QM)"/$(CSEP) >> $@ + @echo $(SQM) $(SQM)$(OSEP)manifest:file-entry manifest:media-type="$(QM)application/vnd.sun.star.configuration-data$(QM)" >> $@ + @echo $(SQM) $(SQM)manifest:full-path="$(QM)ObjectInspector.xcu$(QM)"/$(CSEP) >> $@ + @echo $(SQM) $(SQM)$(OSEP)manifest:file-entry manifest:media-type="$(QM)application/vnd.sun.star.uno-typelibrary;type=RDB$(QM)" >> $@ + @echo $(SQM) $(SQM)manifest:full-path="$(QM)$(subst /META-INF,,$(subst $(SAMPLE_GEN_OUT)/,,$(@D))).uno.rdb$(QM)"/$(CSEP) >> $@ + @echo $(SQM) $(SQM)$(OSEP)manifest:file-entry manifest:media-type="$(QM)application/vnd.sun.star.uno-component;type=Java$(QM)" >> $@ + @echo $(SQM) $(SQM)manifest:full-path="$(QM)$(subst /META-INF,,$(subst $(SAMPLE_GEN_OUT)/,,$(@D))).uno.jar$(QM)"/$(CSEP) >> $@ + @echo $(OSEP)/manifest:manifest$(CSEP) >> $@ + +# rule for component package file +$(COMP_PACKAGE) : $(COMP_RDB) $(COMP_JAR) Addons.xcu ProtocolHandler.xcu ObjectInspector.xcu ObjectInspector.xcs $(COMP_UNOPKG_MANIFEST) + -$(DEL) $(subst \\,\,$(subst /,$(PS),$@)) + -$(MKDIR) $(subst /,$(PS),$(@D)) + cd $(subst /,$(PS),$(COMP_GEN_OUT)) && $(SDK_ZIP) ../../../bin/$(@F) $(COMP_RDB_NAME) + + cd $(subst /,$(PS),$(SAMPLE_CLASS_OUT)) && $(SDK_ZIP) -u ../../bin/$(@F) $(COMP_JAR_NAME) + $(SDK_ZIP) -u $@ Addons.xcu ProtocolHandler.xcu ObjectInspector.xcu ObjectInspector.xcs + cd $(subst /,$(PS),$(COMP_GEN_OUT)) && $(SDK_ZIP) -u ../../../bin/$(@F) META-INF/manifest.xml + +$(COMP_REGISTERFLAG) : $(COMP_PACKAGE) +ifeq "$(SDK_AUTO_DEPLOYMENT)" "YES" + -$(DEL) $(subst \\,\,$(subst /,$(PS),$@)) + -$(MKDIR) $(subst /,$(PS),$(@D)) + $(DEPLOYTOOL) $(COMP_PACKAGE_URL) + @echo flagged > $(subst /,$(PS),$@) +else + @echo -------------------------------------------------------------------------------- + @echo If you want to install your component automatically, please set the environment + @echo variable SDK_AUTO_DEPLOYMENT = YES. But note that auto deployment is only + @echo possible if no office instance is running. + @echo -------------------------------------------------------------------------------- +endif + +JavaInspectorExample : $(COMP_REGISTERFLAG) + @echo -------------------------------------------------------------------------------- + @echo The InstanceInspector component was installed if SDK_AUTO_DEPLOYMENT = YES. + @echo You can use this component inside your office installation, see the example + @echo document. + @echo - + @echo $(MAKE) InstanceInspectorTest.odt.load + @echo -------------------------------------------------------------------------------- + +InstanceInspectorTest.odt.load : $(COMP_REGISTERFLAG) + "$(OFFICE_PROGRAM_PATH)$(PS)soffice" $(basename $@) + +.PHONY: clean +clean : + -$(DELRECURSIVE) $(subst /,$(PS),$(SAMPLE_CLASS_OUT)) + -$(DELRECURSIVE) $(subst /,$(PS),$(SAMPLE_GEN_OUT)) + -$(DEL) $(subst \\,\,$(subst /,$(PS),$(COMP_PACKAGE_URL))) diff --git a/odk/examples/java/Inspector/MethodParametersDialog.java b/odk/examples/java/Inspector/MethodParametersDialog.java new file mode 100644 index 000000000..621e6228b --- /dev/null +++ b/odk/examples/java/Inspector/MethodParametersDialog.java @@ -0,0 +1,351 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import java.awt.BorderLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; +import java.util.ArrayList; + +import javax.swing.JButton; +import javax.swing.JComboBox; +import javax.swing.JComponent; +import javax.swing.JDialog; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.JTextField; + +import com.sun.star.reflection.ParamInfo; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.TypeClass; + +public class MethodParametersDialog extends JDialog{ + private javax.swing.JPanel jPnlParamContainer; + private ParameterPanel[] m_aParameterPanels; + private ParamInfo[] m_aParamInfo; + private XIdlMethod m_xIdlMethod; + private ActionListener oActionListener; + private JButton jHelpButton = new JButton("Help"); + private JButton jOKButton = new JButton("Ok"); + private JButton jInvokeButton = new JButton("Invoke"); + private Object m_oUnoObject = null; + private Object m_oUnoReturnObject = null; + private JLabel jLblResult; + private JPanel jResultPanel = null; + private boolean bisdiposed = false; + private XUnoMethodNode m_xUnoMethodNode; + + + public MethodParametersDialog(XUnoMethodNode _xUnoMethodNode){ + m_xUnoMethodNode = _xUnoMethodNode; + m_xIdlMethod = _xUnoMethodNode.getXIdlMethod(); + m_aParamInfo = m_xIdlMethod.getParameterInfos(); + m_oUnoObject = m_xUnoMethodNode.getUnoObject(); + } + + + public ArrayList<Object> getMethodObjects() { + super.setModal(true); + addBorderPanel(getContentPane(), BorderLayout.NORTH); + addBorderPanel(getContentPane(), BorderLayout.WEST); + addBorderPanel(getContentPane(), BorderLayout.EAST); + jPnlParamContainer = new JPanel(); + jPnlParamContainer.setLayout(new javax.swing.BoxLayout(jPnlParamContainer, javax.swing.BoxLayout.Y_AXIS)); + JPanel jHeaderPanel = new JPanel(new BorderLayout()); + JLabel jLblHeader = new JLabel(); + jLblHeader.setText("Please insert the values for the given Parameters of the method '" + m_xIdlMethod.getName() + "'"); + jHeaderPanel.add(jLblHeader,BorderLayout.WEST); + jPnlParamContainer.add(jHeaderPanel); + + m_aParameterPanels = new ParameterPanel[m_aParamInfo.length]; + for (int i = 0; i < m_aParameterPanels.length; i++){ + m_aParameterPanels[i] = new ParameterPanel(m_aParamInfo[i]); + jPnlParamContainer.add(m_aParameterPanels[i]); + } + jPnlParamContainer.add(new ButtonPanel(), java.awt.BorderLayout.SOUTH); + getContentPane().add(jPnlParamContainer, java.awt.BorderLayout.CENTER); + pack(); + setLocation(350, 350); + setTitle("Object Inspector - Parameter Values of '" + m_xIdlMethod.getName() + "'"); + super.setFocusable(true); + super.setFocusableWindowState(true); + super.requestFocus(); + m_aParameterPanels[0].getInputComponent().requestFocusInWindow(); + setVisible(true); + if (!bisdiposed){ + ArrayList<Object> aMethodObjects = new ArrayList<Object>(); + for (int i = 0; i < m_aParameterPanels.length; i++){ + aMethodObjects.add(m_aParameterPanels[i].getValue()); + } + aMethodObjects.add(m_oUnoReturnObject); + return aMethodObjects; + } + else{ + return null; + } + } + + + private void insertResultPanel(Exception _oInvocationException){ + boolean bAddPanel = false; + if (jResultPanel == null){ + jResultPanel = new JPanel(new BorderLayout()); + bAddPanel = true; + } + else{ + jResultPanel.removeAll(); + } + jLblResult = new JLabel(); + jLblResult.setMaximumSize(new java.awt.Dimension(getSize().width - 20, 57)); + if (_oInvocationException != null){ + jLblResult.setText("<html>Invoking the method cause an exception: <br>" + _oInvocationException.toString() + "</html>"); + } + else{ + jLblResult.setText("<html>The invocation of the method did not produce any error</html>"); + } + jResultPanel.add(jLblResult,BorderLayout.WEST); + if (bAddPanel){ + int nPos = jPnlParamContainer.getComponentCount() - 1; + jPnlParamContainer.add(jResultPanel, nPos); + } + super.pack(); + super.validate(); + } + + + private Object[] getParameterValues(){ + Object[] oParameterValues = new Object[m_aParameterPanels.length]; + for (int i = 0; i < m_aParameterPanels.length; i++){ + oParameterValues[i] = m_aParameterPanels[i].getValue(); + } + return oParameterValues; + } + + + private boolean isCompleted(){ + boolean bIsCompleted = true; + for (int i = 0; i < m_aParameterPanels.length; i++){ + bIsCompleted = m_aParameterPanels[i].isCompleted(); + if (!bIsCompleted){ + break; + } + } + return bIsCompleted; + } + + + private void addBorderPanel(java.awt.Container _jContainer, String _sLayout){ + JPanel jPnlBorder = new JPanel(); + jPnlBorder.setPreferredSize(new java.awt.Dimension(10, 10)); + _jContainer.add(jPnlBorder, _sLayout); + } + + private void addGapPanel(java.awt.Container _jContainer){ + JPanel jPnlBorder = new JPanel(); + jPnlBorder.setPreferredSize(new java.awt.Dimension(10, 10)); + jPnlBorder.setMaximumSize(new java.awt.Dimension(10, 10)); + _jContainer.add(jPnlBorder); + } + + + private class ParameterPanel extends JPanel{ + private JComponent m_jComponent; + private TypeClass m_aTypeClass = null; + + public ParameterPanel(ParamInfo _aParamInfo){ + JTextField jTextField = new JTextField(); + JComboBox jComboBox = new JComboBox(); + m_aTypeClass = _aParamInfo.aType.getTypeClass(); + setLayout(new java.awt.BorderLayout()); + addBorderPanel(this, BorderLayout.NORTH); + addBorderPanel(this, BorderLayout.SOUTH); + JPanel jPnlCenter1 = new javax.swing.JPanel(); + jPnlCenter1.setLayout(new javax.swing.BoxLayout(jPnlCenter1, javax.swing.BoxLayout.X_AXIS)); + JLabel jLabel1 = new JLabel(); + jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.LEFT); + String sParamText = _aParamInfo.aName + " (" + _aParamInfo.aType.getName() +")"; + jLabel1.setText(sParamText); + jPnlCenter1.add(jLabel1); + addGapPanel(jPnlCenter1); + switch (m_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + jComboBox.setBackground(new java.awt.Color(255, 255, 255)); + jComboBox.setPreferredSize(new java.awt.Dimension(50, 19)); + jComboBox.addItem("True"); + jComboBox.addItem("False"); + jComboBox.addKeyListener(new UpdateUIAdapter()); + jPnlCenter1.add(jComboBox); + m_jComponent = jComboBox; + break; + case TypeClass.BYTE_value: + case TypeClass.CHAR_value: + case TypeClass.DOUBLE_value: + case TypeClass.ENUM_value: + case TypeClass.FLOAT_value: + case TypeClass.HYPER_value: + case TypeClass.LONG_value: + case TypeClass.SHORT_value: + case TypeClass.STRING_value: + case TypeClass.UNSIGNED_HYPER_value: + case TypeClass.UNSIGNED_LONG_value: + case TypeClass.UNSIGNED_SHORT_value: + jTextField.setPreferredSize(new java.awt.Dimension(50, 19)); + jTextField.addKeyListener(new UpdateUIAdapter()); + jPnlCenter1.add(jTextField); + m_jComponent = jTextField; + break; + default: + System.out.println("Type " + m_aTypeClass.getValue() + " not yet defined in 'ParameterPanel()'"); + } + add(jPnlCenter1, java.awt.BorderLayout.CENTER); + JPanel jPnlEast = new JPanel(); + add(jPnlEast, BorderLayout.EAST); + } + + private JComponent getInputComponent(){ + return m_jComponent; + } + + public Object getValue(){ + Object oReturn = null; + if (m_jComponent instanceof JTextField){ + String sText = ((JTextField) m_jComponent).getText(); + oReturn = Introspector.getIntrospector().getValueOfText(m_aTypeClass, sText); + } + else{ + JComboBox jComboBox = ((JComboBox) m_jComponent); + oReturn = Boolean.valueOf(jComboBox.getSelectedIndex() == 0); + } + return oReturn; + } + + + public boolean isCompleted(){ + if (m_jComponent instanceof JTextField){ + return !((JTextField) m_jComponent).getText().equals(""); + } + else{ + return true; + } + } + } + + + private class UpdateUIAdapter extends KeyAdapter{ + @Override + public void keyReleased(KeyEvent e){ + boolean bIsCompleted = isCompleted(); + jOKButton.setEnabled(bIsCompleted); + jInvokeButton.setEnabled(bIsCompleted); + if (jLblResult != null){ + jLblResult.setEnabled(false); + jLblResult.invalidate(); + } + } + } + + + + private class ButtonPanel extends JPanel{ + public ButtonPanel(){ + super(); + setLayout(new BorderLayout()); + addBorderPanel(this, BorderLayout.NORTH); + addBorderPanel(this, BorderLayout.SOUTH); + JPanel jPnlBottomCenter = new JPanel(); + jPnlBottomCenter.setLayout(new javax.swing.BoxLayout(jPnlBottomCenter, javax.swing.BoxLayout.X_AXIS)); + jHelpButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + oActionListener.actionPerformed(e); + } + }); + jHelpButton.setEnabled(oActionListener != null); + jPnlBottomCenter.add(jHelpButton); + addGapPanel(jPnlBottomCenter); + jOKButton.setEnabled(false); + jOKButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + invokeParameterMethod(); + dispose(); + } + }); + jOKButton.setEnabled(isCompleted()); + jInvokeButton.setEnabled(isCompleted()); + jInvokeButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + invokeParameterMethod(); + } + }); + + jPnlBottomCenter.add(jOKButton); + addGapPanel(jPnlBottomCenter); + jPnlBottomCenter.add(jInvokeButton); + addGapPanel(jPnlBottomCenter); + JButton jCancelButton = new JButton("Cancel"); + jCancelButton.setFocusCycleRoot(true); + jCancelButton.setFocusPainted(true); + jCancelButton.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + bisdiposed = true; + dispose(); + } + }); + + jPnlBottomCenter.add(jCancelButton); + add(jPnlBottomCenter); + } + } + + + public void addActionListener(ActionListener _oActionListener){ + oActionListener = _oActionListener; + jHelpButton.setEnabled(oActionListener != null); + } + + + private void invokeParameterMethod(){ + try{ + Object[] oParameters = getParameterValues(); + m_oUnoReturnObject = m_xUnoMethodNode.invoke(m_oUnoObject, oParameters); + insertResultPanel(null); + } catch (Exception ex) { + insertResultPanel(ex); + m_oUnoReturnObject = null; + }} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/ObjectInspector.xcs b/odk/examples/java/Inspector/ObjectInspector.xcs new file mode 100644 index 000000000..552e72ef8 --- /dev/null +++ b/odk/examples/java/Inspector/ObjectInspector.xcs @@ -0,0 +1,34 @@ +<?xml version='1.0' encoding='UTF-8'?> +<!-- + * 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 . +--> +<oor:component-schema + xmlns:oor="http://openoffice.org/2001/registry" + xmlns:xs="http://www.w3.org/2001/XMLSchema" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + oor:name="ObjectInspector" + oor:package="org.openoffice.inspector" + xml:lang="en-US"> + <info> + <desc>Configuration parameters for the Object Inspector.</desc> + </info> + <component> + <prop oor:name="Language" oor:type="xs:string"/> + <prop oor:name="SDKPath" oor:type="xs:string"/> + </component> + +</oor:component-schema> diff --git a/odk/examples/java/Inspector/ObjectInspector.xcu b/odk/examples/java/Inspector/ObjectInspector.xcu new file mode 100644 index 000000000..b76960866 --- /dev/null +++ b/odk/examples/java/Inspector/ObjectInspector.xcu @@ -0,0 +1,35 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + * 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 . +--> +<!DOCTYPE local [ + <!ENTITY ProductName "Object Inspector"> + <!ENTITY ProductVersion "0.8"> +]> +<oor:component-data + xmlns:oor="http://openoffice.org/2001/registry" + xmlns:xs="http://www.w3.org/2001/XMLSchema" + oor:name="ObjectInspector" oor:package="org.openoffice.inspector"> + <prop oor:name="Language" oor:type="xs:string"> + <value>Java</value> + </prop> + <prop oor:name="SDKPath" oor:type="xs:string"> + <value></value> + </prop> + +</oor:component-data> + diff --git a/odk/examples/java/Inspector/ProtocolHandler.xcu b/odk/examples/java/Inspector/ProtocolHandler.xcu new file mode 100644 index 000000000..30f3b6b44 --- /dev/null +++ b/odk/examples/java/Inspector/ProtocolHandler.xcu @@ -0,0 +1,28 @@ +<?xml version='1.0' encoding='UTF-8'?> +<!-- + * 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 . +--> +<oor:component-data oor:name="ProtocolHandler" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> + <node oor:name="HandlerSet"> + <node oor:name="InspectorAddon$InspectorAddonImpl" oor:op="replace"> + <prop oor:name="Protocols" oor:type="oor:string-list"> + <value>org.openoffice.Office.addon.Inspector:*</value> + </prop> + </node> + </node> +</oor:component-data> + diff --git a/odk/examples/java/Inspector/ProtocolHandlerAddon.java b/odk/examples/java/Inspector/ProtocolHandlerAddon.java new file mode 100644 index 000000000..51158c392 --- /dev/null +++ b/odk/examples/java/Inspector/ProtocolHandlerAddon.java @@ -0,0 +1,273 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.uno.XComponentContext; +import com.sun.star.lib.uno.helper.Factory; +import com.sun.star.lang.XSingleComponentFactory; +import com.sun.star.lib.uno.helper.WeakBase; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.registry.XRegistryKey; +import com.sun.star.lang.XInitialization; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.frame.XStatusListener; +import com.sun.star.frame.XDispatchProvider; +import com.sun.star.frame.XDispatch; +import com.sun.star.frame.XFrame; +import com.sun.star.frame.DispatchDescriptor; +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; + +public class ProtocolHandlerAddon { + /** This class implements the component. At least the interfaces XServiceInfo, + * XTypeProvider, and XInitialization should be provided by the service. + */ + public static class ProtocolHandlerAddonImpl extends WeakBase implements + XDispatchProvider, + XDispatch, + XInitialization, + XServiceInfo { + + /** The service name, that must be used to get an instance of this service. + */ + private static final String[] m_serviceNames = { "com.sun.star.frame.ProtocolHandler" }; + + /** The component context, that gives access to the service manager and all registered services. + */ + private XComponentContext m_xCmpCtx; + + /** The toolkit, that we can create UNO dialogs. + */ + private XToolkit m_xToolkit; + + /** The frame where the addon depends on. + */ + private XFrame m_xFrame; + + + /** The constructor of the inner class has a XMultiServiceFactory parameter. + * @param xComponentContext A special service factory + * could be introduced while initializing. + */ + public ProtocolHandlerAddonImpl( XComponentContext xComponentContext ) { + m_xCmpCtx = xComponentContext; + } + + /** This method is a member of the interface for initializing an object + * directly after its creation. + * @param object This array of arbitrary objects will be passed to the + * component after its creation. + * @throws com.sun.star.uno.Exception Every exception will not be handled, but will be + * passed to the caller. + */ + public void initialize( Object[] object ) + throws com.sun.star.uno.Exception { + + if ( object.length > 0 ) + { + m_xFrame = UnoRuntime.queryInterface( + XFrame.class, object[ 0 ] ); + } + + // 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)); + } + + /** This method returns an array of all supported service names. + * @return Array of supported service names. + */ + public String[] getSupportedServiceNames() { + return getServiceNames(); + } + + private static String[] getServiceNames() { + return m_serviceNames; + } + + /** This method returns true, if the given service will be + * supported by the component. + * @param sService Service name. + * @return True, if the given service name will be supported. + */ + public boolean supportsService( String sService ) { + int len = m_serviceNames.length; + + for( int i=0; i < len; i++) { + if ( sService.equals( m_serviceNames[i] ) ) + return true; + } + + return false; + } + + /** Return the class name of the component. + * @return Class name of the component. + */ + public String getImplementationName() { + return ProtocolHandlerAddonImpl.class.getName(); + } + + // XDispatchProvider + public XDispatch queryDispatch( /*IN*/com.sun.star.util.URL aURL, + /*IN*/String sTargetFrameName, + /*IN*/int iSearchFlags ) { + XDispatch xRet = null; + if ( aURL.Protocol.equals("org.openoffice.Office.addon.example:") ) { + if ( aURL.Path.equals( "Function1" ) ) + xRet = this; + if ( aURL.Path.equals( "Function2" ) ) + xRet = this; + if ( aURL.Path.equals( "Help" ) ) + xRet = this; + } + return xRet; + } + + public XDispatch[] queryDispatches( /*IN*/DispatchDescriptor[] seqDescripts ) { + int nCount = seqDescripts.length; + XDispatch[] lDispatcher = new XDispatch[nCount]; + + for( int i=0; i<nCount; ++i ) + lDispatcher[i] = queryDispatch( seqDescripts[i].FeatureURL, + seqDescripts[i].FrameName, + seqDescripts[i].SearchFlags ); + + return lDispatcher; + } + + // XDispatch + public void dispatch( /*IN*/com.sun.star.util.URL aURL, + /*IN*/com.sun.star.beans.PropertyValue[] aArguments ) { + + if ( aURL.Protocol.equals("org.openoffice.Office.addon.example:") ) + { + if ( aURL.Path.equals( "Function1" ) ) + { + showMessageBox("SDK DevGuide Add-On example", "Function 1 activated"); + } + if ( aURL.Path.equals( "Function2" ) ) + { + showMessageBox("SDK DevGuide Add-On example", "Function 2 activated"); + } + if ( aURL.Path.equals( "Help" ) ) + { + showMessageBox("About SDK DevGuide Add-On example", "This is the SDK Add-On example"); + } + } + } + + public void addStatusListener( /*IN*/XStatusListener xControl, + /*IN*/com.sun.star.util.URL aURL ) { + } + + public void removeStatusListener( /*IN*/XStatusListener xControl, + /*IN*/com.sun.star.util.URL aURL ) { + } + + private void showMessageBox(String sTitle, String sMessage) { + if ( null != m_xFrame && null != m_xToolkit ) { + + // describe window properties. + WindowDescriptor aDescriptor = new WindowDescriptor(); + aDescriptor.Type = WindowClass.MODALTOP; + aDescriptor.WindowServiceName = "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(); + } + } + } + } + } + + + /** Gives a factory for creating the service. + * This method is called by the <code>JavaLoader</code> + * <p> + * @return Returns a <code>XSingleServiceFactory</code> for creating the + * component. + * @see com.sun.star.comp.loader.JavaLoader + * @param sImplementationName The implementation name of the component. + */ + public static XSingleComponentFactory __getComponentFactory( String sImplementationName ) { + XSingleComponentFactory xFactory = null; + + if ( sImplementationName.equals( ProtocolHandlerAddonImpl.class.getName() ) ) + xFactory = Factory.createComponentFactory(ProtocolHandlerAddonImpl.class, + ProtocolHandlerAddonImpl.getServiceNames()); + + return xFactory; + } + + /** Writes the service information into the given registry key. + * This method is called by the <code>JavaLoader</code>. + * @return returns true if the operation succeeded + * @see com.sun.star.comp.loader.JavaLoader + * @see com.sun.star.lib.uno.helper.Factory + * @param xRegistryKey Makes structural information (except regarding tree + * structures) of a single + * registry key accessible. + */ + public static boolean __writeRegistryServiceInfo( + XRegistryKey xRegistryKey ) { + return Factory.writeRegistryServiceInfo( + ProtocolHandlerAddonImpl.class.getName(), + ProtocolHandlerAddonImpl.getServiceNames(), + xRegistryKey ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SourceCodeGenerator.java b/odk/examples/java/Inspector/SourceCodeGenerator.java new file mode 100644 index 000000000..9ff6ad793 --- /dev/null +++ b/odk/examples/java/Inspector/SourceCodeGenerator.java @@ -0,0 +1,1635 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import java.util.ArrayList; +import java.util.HashMap; + +import com.sun.star.reflection.ParamInfo; +import com.sun.star.reflection.XIdlClass; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.reflection.XTypeDescription; +import com.sun.star.uno.Any; +import com.sun.star.uno.AnyConverter; +import com.sun.star.uno.TypeClass; + + + +public class SourceCodeGenerator { + private ArrayList<String> sExceptions = new ArrayList<String>(); + private ArrayList<String> sHeaderStatements = new HeaderStatements(); + private XLanguageSourceCodeGenerator m_xLanguageSourceCodeGenerator; + private String sStatementCode = ""; + private String sMainMethodSignature = ""; + + private HashMap<String, UnoObjectDefinition> aVariables = new HashMap<String, UnoObjectDefinition>(); + private final String SSUFFIXSEPARATOR = "_"; + private final String SVARIABLENAME = "VariableName"; + private Introspector m_oIntrospector; + private ArrayList<XTreePathProvider> aTreepathProviders = new ArrayList<XTreePathProvider>(); + private boolean baddExceptionHandling = false; + private boolean bXPropertySetExceptionsAreAdded = false; + private XUnoNode oInitialUnoNode = null; + private final String sINITIALVARIABLENAME = "_oUnoEntryObject"; + + + /** Creates a new instance of SourceCodeGenerator */ + public SourceCodeGenerator(int _nLanguage) { + this.setLanguage(_nLanguage); + m_oIntrospector = Introspector.getIntrospector(); + } + + + public String addSourceCodeOfUnoObject(XTreePathProvider _xTreepathProvider, boolean _brememberPath, boolean _baddHeader){ + String sVariableName = ""; + if (_xTreepathProvider != null) { + for (int i = 0; i < _xTreepathProvider.getPathCount(); i++){ + XUnoNode oUnoNode = _xTreepathProvider.getPathComponent(i); + if (i == 0){ + sVariableName = sINITIALVARIABLENAME; + oInitialUnoNode = oUnoNode; + } + else{ + if (oUnoNode instanceof XUnoMethodNode){ + XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode; + if (oUnoMethodNode.isInvoked()){ + UnoObjectDefinition oUnoReturnObjectDefinition = getUnoObjectDefinition(_xTreepathProvider, oUnoMethodNode, i); + if (!isVariableDeclared(oUnoReturnObjectDefinition, this.generateVariableNameFromMethod(oUnoMethodNode.getXIdlMethod()))){ + sStatementCode += "\n" + getMethodStatementSourceCode(oUnoMethodNode, sVariableName, oUnoReturnObjectDefinition); + } + sVariableName = oUnoReturnObjectDefinition.getVariableName(); + } + } + else if (oUnoNode instanceof XUnoPropertyNode){ + XUnoPropertyNode oUnoPropertyNode = (XUnoPropertyNode) oUnoNode; + Any oReturnObject = com.sun.star.uno.Any.complete(oUnoPropertyNode.getUnoReturnObject()); + UnoObjectDefinition oUnoReturnObjectDefinition = new UnoObjectDefinition(oReturnObject); + if (!isVariableDeclared(oUnoReturnObjectDefinition, oUnoPropertyNode.getProperty().Name)){ + sStatementCode += "\n" + getPropertyStatementSourceCode(oUnoPropertyNode, sVariableName, oUnoReturnObjectDefinition); + } + sVariableName = oUnoReturnObjectDefinition.getVariableName(); + } + } + } + } + String sCompleteCode = combineCompleteSourceCode(_baddHeader); + if (_brememberPath){ + aTreepathProviders.add(_xTreepathProvider); + } + return sCompleteCode; + } + + + private void setLanguage(int _nLanguage){ + XLanguageSourceCodeGenerator xLanguageSourceCodeGenerator = null; + switch(_nLanguage){ + case XLanguageSourceCodeGenerator.nJAVA: + xLanguageSourceCodeGenerator = new JavaCodeGenerator(); + break; + case XLanguageSourceCodeGenerator.nCPLUSPLUS: + xLanguageSourceCodeGenerator = new CPlusPlusCodeGenerator(); + break; + case XLanguageSourceCodeGenerator.nBASIC: + xLanguageSourceCodeGenerator = new BasicCodeGenerator(); + break; + default: + System.out.println("Unknown Sourcecode Language. Check Menus!"); + } + if (xLanguageSourceCodeGenerator != null){ + m_xLanguageSourceCodeGenerator = xLanguageSourceCodeGenerator; + } + } + + private void resetSourceCodeGeneration(int _nLanguage){ + aVariables.clear(); + this.sHeaderStatements.clear(); + setLanguage(_nLanguage); + sStatementCode = ""; + } + + private String generateVariableNameFromMethod(String _sMethodName, String _sPrefix, boolean _bConsiderAll){ + String sReturn = ""; + if (_sMethodName.startsWith(_sPrefix)){ + int nPrefixLength = _sPrefix.length(); + if (_sMethodName.length() > nPrefixLength){ + String sChar = _sMethodName.substring(nPrefixLength, nPrefixLength + 1); + String sUpperChar = sChar.toUpperCase(); + if (sUpperChar.equals(sChar)){ + if (_bConsiderAll){ + sReturn = _sMethodName; + } + else{ + sReturn = _sMethodName.substring(nPrefixLength, _sMethodName.length()); + } + } + } + } + return sReturn; + } + + + private String generateVariableNameFromMethod(XIdlMethod _xIdlMethod){ + // todo: refactor this!!! + String sMethodName = _xIdlMethod.getName(); + String sReturn = ""; + sReturn = generateVariableNameFromMethod(sMethodName, "getBy", false); + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "get", false); + } + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "attach", false); + } + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "assign", false); + } + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "attach", false); + } + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "create", false); + } + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "is", true); + } + if (sReturn.equals("")){ + sReturn = generateVariableNameFromMethod(sMethodName, "has", true); + } + if (sReturn.equals("")){ + sReturn = sMethodName; + } + return sReturn; + } + + + public String convertAllUnoObjects(int _nLanguage){ + String sSourceCode = ""; + resetSourceCodeGeneration(_nLanguage); + int ncount = aTreepathProviders.size(); + for (int i=0; i< ncount; i++){ + sSourceCode = addSourceCodeOfUnoObject(aTreepathProviders.get(i), false, (i == (ncount-1))); + } + return sSourceCode; + } + + private UnoObjectDefinition getUnoObjectDefinition(XTreePathProvider _xTreePathProvider, XUnoMethodNode _oUnoMethodNode, int _nindex){ + XUnoNode oUnoNode = null; + Object oUnoReturnObject = null; + Object[] oParamObjects = null; + XIdlClass xIdlClass = _oUnoMethodNode.getXIdlMethod().getReturnType(); + String sTypeName = xIdlClass.getName(); + TypeClass aTypeClass = xIdlClass.getTypeClass(); + if (aTypeClass.getValue() != TypeClass.VOID_value){ + if (_xTreePathProvider.getPathCount() > _nindex + 1){ + oUnoNode = _xTreePathProvider.getPathComponent(_nindex + 1); + oUnoReturnObject = oUnoNode.getUnoObject(); + } + } + if (oUnoReturnObject == null){ + oUnoReturnObject = _oUnoMethodNode.getLastUnoReturnObject(); + } + UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(oUnoReturnObject, sTypeName, aTypeClass); + if (_oUnoMethodNode.hasParameters()){ + if (oUnoNode != null){ + oParamObjects = oUnoNode.getParameterObjects(); + } + else{ + oParamObjects = _oUnoMethodNode.getLastParameterObjects(); + } + } + if (oParamObjects != null){ + oUnoObjectDefinition.addParameterObjects(oParamObjects); + } + return oUnoObjectDefinition; + } + + + private String combineCompleteSourceCode(boolean _bAddHeader){ + String sCompleteCode = ""; + if (_bAddHeader){ + sMainMethodSignature = m_xLanguageSourceCodeGenerator.getMainMethodSignatureSourceCode(oInitialUnoNode, sINITIALVARIABLENAME); + m_xLanguageSourceCodeGenerator.assignqueryInterfaceHeaderSourceCode(); + sCompleteCode += getHeaderSourceCode(); + } + sCompleteCode += sMainMethodSignature; + sCompleteCode += sStatementCode; + if (_bAddHeader){ + sCompleteCode += m_xLanguageSourceCodeGenerator.getMethodTerminationSourceCode(); + sCompleteCode += "\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "..."; + } + return sCompleteCode; + } + + + private String getPropertyStatementSourceCode(XUnoPropertyNode _oUnoPropertyNode, String _sVariableName, UnoObjectDefinition _oUnoReturnObjectDefinition){ + String sReturnObjectVariableDefinition = ""; + String sStatement = ""; + String sPropertyName = _oUnoPropertyNode.getProperty().Name; + UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoPropertyNode.getUnoObject(), "com.sun.star.beans.XPropertySet"); + if (!m_xLanguageSourceCodeGenerator.needsqueryInterface() || (oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.STRUCT_value)){ + oUnoObjectDefinition.setVariableName(_sVariableName); + if (oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.STRUCT_value){ + sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, false); + sStatement += m_xLanguageSourceCodeGenerator.getStructSourceCode(sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName(), sPropertyName); + return sStatement; + } + } + sStatement += addQueryInterfaceSourceCode(oUnoObjectDefinition, _sVariableName, "com.sun.star.beans.XPropertySet"); + if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){ + sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, true); + } + sStatement += m_xLanguageSourceCodeGenerator.getPropertyValueGetterSourceCode(sPropertyName, sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName(), _oUnoReturnObjectDefinition.getTypeClass(), _oUnoReturnObjectDefinition.getTypeName()); + addXPropertySetRelatedExceptions(); + return sStatement; + } + + + private String getMethodStatementSourceCode(XUnoMethodNode _oUnoMethodNode, String _sVariableName, UnoObjectDefinition _oUnoReturnObjectDefinition){ + String sReturnObjectVariableDefinition = ""; + String sStatement = ""; + XIdlMethod xIdlMethod = _oUnoMethodNode.getXIdlMethod(); + TypeClass aReturnTypeClass = xIdlMethod.getReturnType().getTypeClass(); + UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoMethodNode.getUnoObject(), _oUnoMethodNode.getClassName()); + String sVariableStemName = this.generateVariableNameFromMethod(xIdlMethod); + sStatement += addQueryInterfaceSourceCode(oUnoObjectDefinition, _sVariableName, oUnoObjectDefinition.getTypeName()); + if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){ + sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, false) + " = "; + } + Object[] oParamObjects = _oUnoReturnObjectDefinition.getParameterObjects(); + String sParameterCode = getMethodParameterValueDescription(_oUnoMethodNode, oParamObjects, false); + String sSeparator = m_xLanguageSourceCodeGenerator.getMethodSeparator(); + sStatement += "\t" + sReturnObjectVariableDefinition + oUnoObjectDefinition.getVariableName() + sSeparator + xIdlMethod.getName() + "(" + sParameterCode + ")"; + sStatement += m_xLanguageSourceCodeGenerator.getStatementTerminationCharacter(); + addExceptions(xIdlMethod); + return sStatement; + } + + + private String addQueryInterfaceSourceCode(UnoObjectDefinition _oUnoObjectDefinition, String _sVariableName, String _sTypeName){ + String sLocStatement = ""; + if (m_xLanguageSourceCodeGenerator.needsqueryInterface()){ + if (!isVariableDeclared(_oUnoObjectDefinition, "")){ + String sObjectVariableDefinition = getVariableDeclaration(_oUnoObjectDefinition, false, ""); + sLocStatement += m_xLanguageSourceCodeGenerator.getqueryInterfaceSourceCode(_sTypeName, sObjectVariableDefinition, _sVariableName); + } + } + else{ + _oUnoObjectDefinition.setVariableName(_sVariableName); + } + return sLocStatement; + } + + + private void addXPropertySetRelatedExceptions(){ + if (!bXPropertySetExceptionsAreAdded){ + sExceptions.add("com.sun.star.beans.UnknownPropertyException"); + sExceptions.add("com.sun.star.lang.WrappedTargetException"); + sExceptions.add("com.sun.star.lang.IllegalArgumentException"); + bXPropertySetExceptionsAreAdded = true; + baddExceptionHandling = true; + } + } + + + private void addExceptions(XIdlMethod _xIdlMethod){ + XIdlClass[] xIdlClasses = _xIdlMethod.getExceptionTypes(); + for (int i = 0; i > xIdlClasses.length; i++){ + sExceptions.add(xIdlClasses[0].getName()); + baddExceptionHandling = true; + } + } + + private String getHeaderSourceCode(){ + for(UnoObjectDefinition oUnoObjectDefinition : aVariables.values()){ + String sCurHeaderStatement = m_xLanguageSourceCodeGenerator.getHeaderSourceCode(oUnoObjectDefinition.getUnoObject(), oUnoObjectDefinition.getTypeName(), oUnoObjectDefinition.getTypeClass()); + sHeaderStatements.add(sCurHeaderStatement); + } + String sHeaderSourcecode = ""; + String[] sHeaderStatementArray = new String[sHeaderStatements.size()]; + sHeaderStatements.toArray(sHeaderStatementArray); + java.util.Arrays.sort(sHeaderStatementArray); + for (int i = 0; i < sHeaderStatementArray.length; i++){ + sHeaderSourcecode += sHeaderStatementArray[i]; + } + sHeaderSourcecode += m_xLanguageSourceCodeGenerator.getFinalHeaderStatements(); + return sHeaderSourcecode +"\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "...\n"; + } + + + private class HeaderStatements extends ArrayList<String> { + + public boolean contains(String _oElement){ + String sCompName = _oElement; + for (int i = 0; i < this.size(); i++){ + String sElement = this.get(i); + if (sElement.equals(sCompName)){ + return true; + } + } + return false; + } + + + @Override + public boolean add(String _oElement){ + if (!contains(_oElement)){ + super.add(_oElement); + return true; + } + return false; + } + } + + + private boolean isVariableDeclared(UnoObjectDefinition _oUnoObjectDefinition, String _sDefaultStemName){ + boolean bisDeclared = false; + if (!_sDefaultStemName.equals("")){ + _oUnoObjectDefinition.setCentralVariableStemName(_sDefaultStemName); + } + String sVariableStemName = _oUnoObjectDefinition.getVariableStemName(); + bisDeclared = aVariables.containsKey(sVariableStemName); + if (bisDeclared){ + Object oUnoObject = _oUnoObjectDefinition.getUnoObject(); + if (Introspector.isObjectPrimitive(oUnoObject)){ + bisDeclared = false; + } + else if (Introspector.isObjectSequence(oUnoObject)){ + bisDeclared = false; + } + else{ + String sCompVariableName = sVariableStemName; + String sUnoObjectIdentity = oUnoObject.toString(); + boolean bleaveloop = false; + int a = 2; + while (!bleaveloop){ + if (aVariables.containsKey(sCompVariableName)){ + Object oUnoCompObject = aVariables.get(sCompVariableName).getUnoObject(); + String sUnoCompObjectIdentity = oUnoCompObject.toString(); + bleaveloop = sUnoCompObjectIdentity.equals(sUnoObjectIdentity); + bisDeclared = bleaveloop; + if (!bleaveloop){ + sCompVariableName = sVariableStemName + SSUFFIXSEPARATOR + a++; + } + } + else{ + bleaveloop = true; + bisDeclared = false; + } + } + } + } + return bisDeclared; + } + + + private String addUniqueVariableName(String _sStemVariableName, UnoObjectDefinition _oUnoObjectDefinition){ + boolean bElementexists = true; + int a = 2; + String sCompName = _sStemVariableName; + while (bElementexists){ + if (! aVariables.containsKey(sCompName)){ + aVariables.put(sCompName, _oUnoObjectDefinition); + break; + } + sCompName = _sStemVariableName + SSUFFIXSEPARATOR + a++; + } + return sCompName; + } + + + + private String getTypeString(String _sTypeName, TypeClass _aTypeClass, boolean _bAsHeaderSourceCode){ + String sTypeString = ""; + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + sTypeString = m_xLanguageSourceCodeGenerator.getbooleanTypeDescription(); + break; + case TypeClass.BYTE_value: + sTypeString = m_xLanguageSourceCodeGenerator.getbyteTypeDescription(); + break; + case TypeClass.CHAR_value: + sTypeString = m_xLanguageSourceCodeGenerator.getcharTypeDescription(); + break; + case TypeClass.DOUBLE_value: + sTypeString = m_xLanguageSourceCodeGenerator.getdoubleTypeDescription(); + break; + case TypeClass.FLOAT_value: + sTypeString = m_xLanguageSourceCodeGenerator.getfloatTypeDescription(); + break; + case TypeClass.HYPER_value: + sTypeString = m_xLanguageSourceCodeGenerator.gethyperTypeDescription(); + break; + case TypeClass.LONG_value: + sTypeString = m_xLanguageSourceCodeGenerator.getlongTypeDescription(); + break; + case TypeClass.SHORT_value: + sTypeString = m_xLanguageSourceCodeGenerator.getshortTypeDescription(); + break; + case TypeClass.STRING_value: + sTypeString = m_xLanguageSourceCodeGenerator.getstringTypeDescription(_bAsHeaderSourceCode); + break; + case TypeClass.UNSIGNED_HYPER_value: + sTypeString = m_xLanguageSourceCodeGenerator.getunsignedhyperTypeDescription(); + break; + case TypeClass.UNSIGNED_LONG_value: + sTypeString = m_xLanguageSourceCodeGenerator.getunsignedlongTypeDescription(); + break; + case TypeClass.UNSIGNED_SHORT_value: + sTypeString = m_xLanguageSourceCodeGenerator.getdoubleTypeDescription(); + break; + case TypeClass.SEQUENCE_value: + //TODO consider mulitdimensional Arrays + XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(_sTypeName); + if (xTypeDescription != null){ + sTypeString = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), _bAsHeaderSourceCode); + } + break; + case TypeClass.ANY_value: + sTypeString = m_xLanguageSourceCodeGenerator.getanyTypeDescription(_bAsHeaderSourceCode); + break; + case TypeClass.TYPE_value: + sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription("com.sun.star.uno.Type", _bAsHeaderSourceCode); + break; + case TypeClass.ENUM_value: + case TypeClass.STRUCT_value: + case TypeClass.INTERFACE_ATTRIBUTE_value: + case TypeClass.INTERFACE_METHOD_value: + case TypeClass.INTERFACE_value: + case TypeClass.PROPERTY_value: + sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(_sTypeName, _bAsHeaderSourceCode); + break; + default: + } + return sTypeString; + } + + + private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition, boolean _bInitialize, String _sVariableDefaultName){ + TypeClass aTypeClass = _oUnoObjectDefinition.getTypeClass(); + TypeClass aLocTypeClass = aTypeClass; + boolean bIsArray = false; + if (_oUnoObjectDefinition.getUnoObject() != null){ + bIsArray = Introspector.isObjectSequence(_oUnoObjectDefinition.getUnoObject()); + } + else{ + bIsArray = _oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.SEQUENCE_value; + } + String sVariableName = _oUnoObjectDefinition.getVariableName(_sVariableDefaultName); + String sTypeName = _oUnoObjectDefinition.getTypeName(); + String sTypeString = getTypeString(sTypeName, aLocTypeClass, false); + if (bIsArray){ + XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(sTypeName); + if (xTypeDescription != null){ + aLocTypeClass = xTypeDescription.getTypeClass(); + } + } + String sVariableDeclaration = m_xLanguageSourceCodeGenerator.getVariableDeclaration(sTypeString, sVariableName, bIsArray, aLocTypeClass, _bInitialize); + addUniqueVariableName(sVariableName, _oUnoObjectDefinition); + return sVariableDeclaration; + } + + + private String getVariableInitialization(UnoObjectDefinition _oUnoObjectDefinition, boolean _bInitialize){ + String sObjectVariableDeclaration = ""; + String sVariableName = _oUnoObjectDefinition.getVariableName(); + if (isVariableDeclared(_oUnoObjectDefinition, "")){ + sObjectVariableDeclaration = sVariableName; + } + else{ + sObjectVariableDeclaration = getVariableDeclaration(_oUnoObjectDefinition, _bInitialize, ""); + } + return sObjectVariableDeclaration; + } + + + + public String getVariableNameforUnoObject(String _sShortClassName){ + if (_sShortClassName.startsWith("X")){ + return "x" + _sShortClassName.substring(1); + } + else{ + return _sShortClassName; + } + } + + +private class UnoObjectDefinition{ + private Object m_oUnoObject = null; + + private String sVariableStemName = ""; + private String m_sCentralVariableStemName = ""; + private String sVariableName = ""; + private String m_sTypeName = ""; + private TypeClass m_aTypeClass = null; + private Object[] m_oParameterObjects = null; + + + private UnoObjectDefinition(Any _oUnoObject){ + m_sTypeName = _oUnoObject.getType().getTypeName(); + m_aTypeClass = _oUnoObject.getType().getTypeClass(); + m_oUnoObject = _oUnoObject; + m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass); + } + + + private UnoObjectDefinition(Object _oUnoObject, String _sTypeName, TypeClass _aTypeClass){ + m_oUnoObject = _oUnoObject; + m_sTypeName = _sTypeName; + m_aTypeClass = _aTypeClass; + m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass); + } + + + private UnoObjectDefinition(Object _oUnoObject, String _sTypeName){ + m_oUnoObject = _oUnoObject; + m_sTypeName = _sTypeName; + m_aTypeClass = AnyConverter.getType(_oUnoObject).getTypeClass(); + m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass); + } + + + private String getCentralVariableStemName(TypeClass _aTypeClass){ + String sCentralVariableStemName = ""; + int nTypeClass = _aTypeClass.getValue(); + switch(nTypeClass){ + case TypeClass.SEQUENCE_value: + //TODO consider mulitdimensional Arrays + XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName()); + if (xTypeDescription != null){ + sCentralVariableStemName = getCentralVariableStemName(xTypeDescription.getTypeClass()); + } + break; + case TypeClass.TYPE_value: + sCentralVariableStemName = SVARIABLENAME; + break; + case TypeClass.STRUCT_value: + sCentralVariableStemName = Introspector.getShortClassName(getTypeName()); + break; + case TypeClass.INTERFACE_ATTRIBUTE_value: + case TypeClass.INTERFACE_METHOD_value: + case TypeClass.INTERFACE_value: + case TypeClass.PROPERTY_value: + String sShortClassName = Introspector.getShortClassName(getTypeName()); + sCentralVariableStemName = getVariableNameforUnoObject(sShortClassName); + default: + sCentralVariableStemName = SVARIABLENAME; + } + return sCentralVariableStemName; + } + + /** may return null + */ + public Object getUnoObject(){ + return m_oUnoObject; + } + + + public TypeClass getTypeClass(){ + return m_aTypeClass; + } + + + public String getTypeName(){ + return m_sTypeName; + } + + + public void setCentralVariableStemName(String _sCentralVariableStemName){ + m_sCentralVariableStemName = _sCentralVariableStemName; + } + + + public String getVariableStemName(){ + if (sVariableStemName.equals("")){ + sVariableStemName = getVariableStemName(m_aTypeClass); + } + return sVariableStemName; + } + + + private void addParameterObjects(Object[] _oParameterObjects){ + m_oParameterObjects = _oParameterObjects; + } + + + public Object[] getParameterObjects(){ + return m_oParameterObjects; + } + + + + + + private String getVariableStemName(TypeClass _aTypeClass){ + int nTypeClass = _aTypeClass.getValue(); + switch(nTypeClass){ + case TypeClass.BOOLEAN_value: + sVariableStemName = "b" + m_sCentralVariableStemName; + break; + case TypeClass.DOUBLE_value: + case TypeClass.FLOAT_value: + sVariableStemName = "f" + m_sCentralVariableStemName; + break; + case TypeClass.BYTE_value: + case TypeClass.HYPER_value: + case TypeClass.LONG_value: + case TypeClass.UNSIGNED_HYPER_value: + case TypeClass.UNSIGNED_LONG_value: + case TypeClass.UNSIGNED_SHORT_value: + case TypeClass.SHORT_value: + sVariableStemName = "n" + m_sCentralVariableStemName; + break; + case TypeClass.CHAR_value: + case TypeClass.STRING_value: + sVariableStemName = "s" + m_sCentralVariableStemName; + break; + case TypeClass.SEQUENCE_value: + //TODO consider mulitdimensional Arrays + XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName()); + if (xTypeDescription != null){ + sVariableStemName = getVariableStemName(xTypeDescription.getTypeClass()); + } + break; + case TypeClass.TYPE_value: + sVariableStemName = "a" + m_sCentralVariableStemName; + break; + case TypeClass.ANY_value: + sVariableStemName = "o" + m_sCentralVariableStemName; + break; + case TypeClass.STRUCT_value: + case TypeClass.ENUM_value: + sVariableStemName = "a" + m_sCentralVariableStemName; + break; + case TypeClass.INTERFACE_ATTRIBUTE_value: + case TypeClass.INTERFACE_METHOD_value: + case TypeClass.INTERFACE_value: + case TypeClass.PROPERTY_value: + String sShortClassName = Introspector.getShortClassName(getTypeName()); + sVariableStemName = getVariableNameforUnoObject(sShortClassName); + default: + } + return sVariableStemName; + } + + + private void setVariableName(String _sVariableName){ + sVariableName = _sVariableName; + } + + + private String getVariableName(String _sCentralVariableStemName){ + if (!_sCentralVariableStemName.equals("")){ + this.m_sCentralVariableStemName = _sCentralVariableStemName; + } + return getVariableName(); + } + + + private String getVariableName() throws NullPointerException{ + if (sVariableName.equals("")){ + int a = 2; + sVariableName = getVariableStemName(); + boolean bleaveloop = false; + while (!bleaveloop){ + if (aVariables.containsKey(sVariableName)){ + String sUnoObjectIdentity = aVariables.get(sVariableName).getUnoObject().toString(); + if (m_oUnoObject != null){ + if ((sUnoObjectIdentity.equals(m_oUnoObject.toString()) && (!Introspector.isPrimitive(this.getTypeClass())) && + (! Introspector.isObjectSequence(m_oUnoObject)))){ + bleaveloop = true; + } + else{ + sVariableName = getVariableStemName() + SSUFFIXSEPARATOR + a++; + } + } + else{ + bleaveloop = true; + } + } + else{ + bleaveloop = true; + } + } + } + return sVariableName; + } + } + + + public String getStringValueOfObject(Object _oUnoObject, TypeClass _aTypeClass){ + String sReturn = ""; + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + boolean bbooleanValue = ((Boolean) _oUnoObject).booleanValue(); + sReturn += Boolean.toString(bbooleanValue); + case TypeClass.CHAR_value: + break; + case TypeClass.DOUBLE_value: + double fdoubleValue = ((Double) _oUnoObject).doubleValue(); + sReturn += Double.toString(fdoubleValue); + break; + case TypeClass.ENUM_value: + break; + case TypeClass.FLOAT_value: + float floatValue = ((Float) _oUnoObject).floatValue(); + sReturn += Float.toString(floatValue); + break; + case TypeClass.HYPER_value: + long nlongValue = ((Long) _oUnoObject).longValue(); + sReturn += Long.toString(nlongValue); + break; + case TypeClass.LONG_value: + int nintValue = ((Integer) _oUnoObject).intValue(); + sReturn += Integer.toString(nintValue); + break; + case TypeClass.SHORT_value: + short nshortValue = ((Short) _oUnoObject).shortValue(); + sReturn += Short.toString(nshortValue); + break; + case TypeClass.STRING_value: + sReturn += (String) _oUnoObject; + break; + case TypeClass.UNSIGNED_HYPER_value: + nlongValue = ((Long) _oUnoObject).longValue(); + sReturn += Long.toString(nlongValue); + break; + case TypeClass.UNSIGNED_LONG_value: + nintValue = ((Integer) _oUnoObject).intValue(); + sReturn += Integer.toString(nintValue); + break; + case TypeClass.UNSIGNED_SHORT_value: + nshortValue = ((Short) _oUnoObject).shortValue(); + sReturn += Short.toString(nshortValue); + break; + default: + System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'getStringValueOfObject()'"); + } + return sReturn; + } + + + public String getMethodParameterValueDescription(XUnoMethodNode _oUnoMethodNode, Object[] _oParamObjects, boolean _bIncludeParameterNames){ + String sParamSourceCode = ""; + ParamInfo[] aParamInfos = _oUnoMethodNode.getXIdlMethod().getParameterInfos(); + if (_oParamObjects != null){ + for (int i = 0; i < _oParamObjects.length; i++){ + TypeClass aTypeClass = aParamInfos[i].aType.getTypeClass(); + if (_bIncludeParameterNames){ + sParamSourceCode += aParamInfos[i].aName + "="; + } + String sParamDescription = getStringValueOfObject(_oParamObjects[i], aTypeClass); + sParamDescription = this.m_xLanguageSourceCodeGenerator.castLiteral(sParamDescription, aTypeClass); + sParamSourceCode += sParamDescription; + + if (i < _oParamObjects.length - 1){ + sParamSourceCode += ", "; + } + } + } + return sParamSourceCode; + } + + + private class JavaCodeGenerator implements XLanguageSourceCodeGenerator{ + + private boolean bAddAnyConverter = false; + private boolean bIsPropertyUnoObjectDefined = false; + + public JavaCodeGenerator(){ + } + + + public String getStatementTerminationCharacter(){ + return ";"; + } + + + public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){ + String sClassName = _sClassName; + String sHeaderStatement = ""; + if (_oUnoObject != null){ + if (!Introspector.isObjectPrimitive(_oUnoObject)){ + if (Introspector.isObjectSequence(_oUnoObject)){ + XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName); + if (xTypeDescription != null){ + if (!Introspector.isPrimitive(xTypeDescription.getTypeClass())){ + sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true); + } + // primitive Types are not supposed to turn up in the import section... + else{ + sClassName = ""; + } + } + } + else{ + sClassName = getTypeString(_sClassName, _aTypeClass, true); + } + } + else if (_aTypeClass.getValue() == TypeClass.ENUM_value){ + sClassName = _sClassName; + } + else{ + sClassName = ""; + } + if (!sClassName.equals("")){ + sHeaderStatement = "import " + sClassName + ";\n"; + } + } + return sHeaderStatement; + } + + + public String getFinalHeaderStatements(){ + return ""; + } + + + public void assignqueryInterfaceHeaderSourceCode(){ + sHeaderStatements.add("import com.sun.star.uno.UnoRuntime;\n"); + sHeaderStatements.add("import com.sun.star.uno.XInterface;\n"); + if (bAddAnyConverter){ + sHeaderStatements.add("import com.sun.star.uno.AnyConverter;\n"); + } + } + + + + public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){ + boolean bLocAddAnyConverter = true; + String sReturn = ""; + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + sReturn = _sReturnVariableName + " = AnyConverter.toBoolean(" + _sObjectDescription + ")"; + break; + case TypeClass.CHAR_value: + sReturn = _sReturnVariableName + " = AnyConverter.toChar(" + _sObjectDescription + ")"; + break; + case TypeClass.BYTE_value: + sReturn = _sReturnVariableName + " = AnyConverter.toByte(" + _sObjectDescription + ")"; + break; + case TypeClass.DOUBLE_value: + sReturn = _sReturnVariableName + " = AnyConverter.toDouble(" + _sObjectDescription + ")"; + break; + case TypeClass.FLOAT_value: + sReturn = _sReturnVariableName + " = AnyConverter.toFloat(" + _sObjectDescription + ")"; + break; + case TypeClass.UNSIGNED_HYPER_value: + sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedLong(" + _sObjectDescription + ")"; + break; + case TypeClass.HYPER_value: + sReturn = _sReturnVariableName + " = AnyConverter.toLong(" + _sObjectDescription + ")"; + break; + case TypeClass.UNSIGNED_LONG_value: + sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedInt(" + _sObjectDescription + ")"; + break; + case TypeClass.LONG_value: + sReturn = _sReturnVariableName + " = AnyConverter.toInt(" + _sObjectDescription + ")"; + break; + case TypeClass.SHORT_value: + sReturn = _sReturnVariableName + " = AnyConverter.toShort(" + _sObjectDescription + ")"; + break; + case TypeClass.UNSIGNED_SHORT_value: + sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedShort(" + _sObjectDescription + ")"; + break; + case TypeClass.STRING_value: + sReturn = _sReturnVariableName + " = AnyConverter.toString(" + _sObjectDescription + ")"; + break; + default: + String sShortTypeName = Introspector.getShortClassName(_sTypeName); + if (bIsPropertyUnoObjectDefined){ + sReturn = "oUnoObject = " + _sObjectDescription + ";\n\t"; + } + else{ + sReturn = "Object oUnoObject = " + _sObjectDescription + ";\n\t"; + bIsPropertyUnoObjectDefined = true; + } + sReturn += _sReturnVariableName + " = (" + sShortTypeName + ") AnyConverter.toObject(" + sShortTypeName + ".class, oUnoObject);"; + break; + } + if (!bAddAnyConverter){ + bAddAnyConverter = bLocAddAnyConverter; + } + return sReturn; + } + + + public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){ + return "\t" + _sReturnVariableDescription + " = " + _sObjectDescription + "." + _sMember + ";"; + } + + public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){ + //TODO try to use + _oUnoNode.getClassName() instead of the hack + String sReturn = "public void codesnippet(XInterface " + _soReturnObjectDescription + "){"; + if (baddExceptionHandling){ + sReturn += "\ntry{"; + } + return sReturn; + } + + public String getMethodSeparator(){ + return "."; + } + + public boolean needsqueryInterface(){ + return true; + } + + public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){ + String sShortClassName = Introspector.getShortClassName(_sClassName); + return "\t" + _sReturnVariableName + " = (" + sShortClassName + ") UnoRuntime.queryInterface(" + sShortClassName + ".class, " + _sIncomingObjectName + ");\n"; + } + + + public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){ + String sObjectDescription = _sIncomingObjectName + ".getPropertyValue(\"" + _sPropertyName + "\")"; + String sReturn = getConvertedSourceCodeValueOfObject(_sReturnVariableName, sObjectDescription, _aTypeClass, _sTypeName); + sReturn += ";"; + sReturn = "\t" + sReturn; + return sReturn; + } + + + public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){ + String sReturn = ""; + if (_bAsHeader){ + sReturn = _sClassName; + } + else{ + sReturn = Introspector.getShortClassName(_sClassName); + } + return sReturn; + } + + + public String getMethodTerminationSourceCode(){ + String sReturn = ""; + int nIndex = 1; + String sExceptionName = "e"; + if (baddExceptionHandling){ + for (int i = 0; i < sExceptions.size(); i++){ + String sCurException = sExceptions.get(i); + if (sReturn.indexOf(sCurException) == -1){ + if (nIndex > 1){ + sExceptionName = "e"+ nIndex; + } + else{ + sReturn +="\n}"; + } + sReturn += "catch (" + sCurException + " " + sExceptionName + "){\n"; + sReturn += "\t" + sExceptionName + ".printStackTrace(System.err);\n"; + sReturn += "\t" + getCommentSign() + "Enter your Code here...\n}"; + nIndex++; + } + } + } + sReturn += "\n}"; + return sReturn; + } + + public String castLiteral(String _sExpression, TypeClass _aTypeClass){ + String sReturn = ""; + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + sReturn = _sExpression; + break; + case TypeClass.BYTE_value: + sReturn = "(byte) " + _sExpression; + break; + case TypeClass.CHAR_value: + sReturn = "'" + _sExpression + "'"; + break; + case TypeClass.DOUBLE_value: + sReturn = "(double) " + _sExpression; + break; + case TypeClass.FLOAT_value: + sReturn = "(float) " + _sExpression; + break; + case TypeClass.UNSIGNED_SHORT_value: + case TypeClass.SHORT_value: + sReturn = "(short) " + _sExpression; + break; + case TypeClass.STRING_value: + sReturn = "\"" + _sExpression + "\""; + break; + case TypeClass.HYPER_value: + case TypeClass.UNSIGNED_HYPER_value: + sReturn = "(long) " + _sExpression; + break; + case TypeClass.LONG_value: + sReturn = _sExpression; + break; + case TypeClass.ENUM_value: + default: + sReturn = _sExpression; + System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'"); + } + return sReturn; + } + + + public String getbooleanTypeDescription(){ + return "boolean"; + } + + public String getbyteTypeDescription(){ + return "byte"; + } + + public String getshortTypeDescription(){ + return "short"; + } + + public String getlongTypeDescription(){ + return "int"; + } + + public String getunsignedlongTypeDescription(){ + return "int"; + } + + public String gethyperTypeDescription(){ + return "long"; + } + + public String getunsignedhyperTypeDescription(){ + return "long"; + } + + public String getfloatTypeDescription(){ + return "float"; + } + + public String getdoubleTypeDescription(){ + return "double"; + } + + public String getcharTypeDescription(){ + return "char"; + } + + public String getstringTypeDescription(boolean _bAsHeaderSourceCode){ + if (_bAsHeaderSourceCode){ + return ""; + } + else{ + return "String"; + } + } + + public String getanyTypeDescription(boolean _bAsHeaderSourceCode){ + if (_bAsHeaderSourceCode){ + return ""; + } + else{ + return "Object"; + } + } + + + public String getStringValue(String _sValue){ + return _sValue; + } + + + public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean _bIsArray, TypeClass _aTypeClass, boolean _bInitialize){ + String sReturn = ""; + if (_bIsArray){ + sReturn = _sTypeString + "[] " + _sVariableName; + } + else{ + sReturn = _sTypeString + " " + _sVariableName; + } + return sReturn; + } + + + public String getCommentSign(){ + return "//"; + } + } + + + private class BasicCodeGenerator implements XLanguageSourceCodeGenerator{ + + + public BasicCodeGenerator(){ + } + + public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){ + String sHeaderStatement = ""; + return sHeaderStatement; + } + + public String getFinalHeaderStatements(){ + return ""; + } + + public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){ + //TODO try to use + _oUnoNode.getClassName() instead of the hack + return "Sub Main(" + _soReturnObjectDescription + " as " + getanyTypeDescription(false) + ")"; + } + + public boolean needsqueryInterface(){ + return false; + } + + public void assignqueryInterfaceHeaderSourceCode(){ + } + + public String getMethodSeparator(){ + return "."; + } + + + public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){ + return _sIncomingObjectName; + } + + + public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){ + return "\t" + _sReturnVariableName + " = " + _sIncomingObjectName + "." + _sPropertyName; + } + + + public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){ + return getPropertyValueGetterSourceCode(_sMember, _sReturnVariableDescription, _sObjectDescription, null, "" ); + } + + public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){ + return _sReturnVariableName + " = " + _sObjectDescription; + } + + + public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){ + return "Object"; + } + + + public String getMethodTerminationSourceCode(){ + return "\nEnd Sub\n"; + } + + + public String castLiteral(String _sExpression, TypeClass _aTypeClass){ + String sReturn = ""; + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + case TypeClass.BYTE_value: + case TypeClass.DOUBLE_value: + case TypeClass.FLOAT_value: + case TypeClass.UNSIGNED_SHORT_value: + case TypeClass.SHORT_value: + case TypeClass.LONG_value: + case TypeClass.UNSIGNED_LONG_value: + case TypeClass.HYPER_value: + case TypeClass.UNSIGNED_HYPER_value: + sReturn = _sExpression; + break; + case TypeClass.CHAR_value: + case TypeClass.STRING_value: + sReturn = "\"" +_sExpression + "\""; + break; + case TypeClass.ENUM_value: + default: + sReturn = _sExpression; + System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'"); + } + return sReturn; + } + + + + public String getbooleanTypeDescription(){ + return "Boolean"; + } + + public String getbyteTypeDescription(){ + return "Integer"; + } + + public String getshortTypeDescription(){ + return "Integer"; + } + + public String getlongTypeDescription(){ + return "Integer"; + } + + public String getunsignedlongTypeDescription(){ + return "Long"; + } + + public String gethyperTypeDescription(){ + return "Long"; + } + + public String getunsignedhyperTypeDescription(){ + return "Long"; + } + + public String getfloatTypeDescription(){ + return "Double"; + } + + public String getdoubleTypeDescription(){ + return "Double"; + } + + public String getcharTypeDescription(){ + return "String"; + } + + public String getstringTypeDescription(boolean _bAsHeaderSourceCode){ + if (_bAsHeaderSourceCode){ + return ""; + } + else{ + return "String"; + } + } + + public String getanyTypeDescription(boolean _bAsHeaderSourceCode){ + if (_bAsHeaderSourceCode){ + return ""; + } + else{ + return "Object"; + } + } + + public String getStatementTerminationCharacter(){ + return ""; + } + + + public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray, TypeClass _aTypeClass, boolean _bInitialize){ + String sReturn = ""; + if (bIsArray){ + sReturn = "Dim " + _sVariableName + "() as " + _sTypeString + "\n\t" + _sVariableName; + } + else{ + sReturn = "Dim " + _sVariableName + " as " + _sTypeString + "\n\t" + _sVariableName; + } + return sReturn; + } + + + public String getStringValue(String _sValue){ + return _sValue; + } + + + public String getCommentSign(){ + return "'"; + } + + } + + private class CPlusPlusCodeGenerator implements XLanguageSourceCodeGenerator{ + + private boolean bIncludeStringHeader = false; + private boolean bIncludeAny = false; + private boolean bIncludeSequenceHeader = false; + + public CPlusPlusCodeGenerator(){ + } + + private String getCSSNameSpaceString(){ + return "css"; + } + + public String getStatementTerminationCharacter(){ + return ";"; + } + + + public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){ + String sClassName = _sClassName; + String sHeaderStatement = ""; + if (_oUnoObject != null){ + if (!Introspector.isObjectPrimitive(_oUnoObject)){ + if (Introspector.isObjectSequence(_oUnoObject)){ + XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName); + if (xTypeDescription != null){ + if (!Introspector.isPrimitive(xTypeDescription.getTypeClass())){ + sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true); + } + // primitive Types are not supposed to turn up in the import section... + else{ + sClassName = ""; + } + } + } + else{ + sClassName = getTypeString(_sClassName, _aTypeClass, true); + } + if (!sClassName.equals("")){ + sHeaderStatement = getHeaderOfClass(sClassName); + } + } + } + return sHeaderStatement; + } + + + + public String getFinalHeaderStatements(){ + String sReturn = ""; + sReturn += "\nnamespace " + getCSSNameSpaceString() + " = com::sun::star;\n"; + sReturn += "using ::rtl::OUString;\n"; + return sReturn; + } + + + private String getHeaderOfClass(String _sClassName){ + return "#include \"" + _sClassName.replace('.', '/') + ".hpp\"\n"; + } + + + + public void assignqueryInterfaceHeaderSourceCode(){ + sHeaderStatements.add("#include \"sal/config.h\"\n"); + sHeaderStatements.add("#include \"sal/types.h\"\n"); + if (bIncludeStringHeader){ + sHeaderStatements.add("#include \"rtl/ustring.hxx\"\n"); + } + sHeaderStatements.add("#include \"com/sun/star/uno/Reference.hxx\"\n"); + if (bIncludeSequenceHeader){ + sHeaderStatements.add("#include \"com/sun/star/uno/Sequence.hxx\"\n"); + } + sHeaderStatements.add(getHeaderOfClass("com.sun.star.uno.XInterface")); + if (bIncludeAny){ + sHeaderStatements.add(getHeaderOfClass("com.sun.star.uno.Any")); + } + } + + + public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){ + String sReturn = ""; + sReturn = "void codesnippet(const " + getCSSNameSpaceString() + "::uno::Reference<" + getCSSNameSpaceString() + "::uno::XInterface>& " + _soReturnObjectDescription + " ){"; + int a = 0; + if (!sExceptions.contains("com.sun.star.uno.RuntimeException")){ + sExceptions.add("com.sun.star.uno.RuntimeException"); + } + if (baddExceptionHandling){ + sReturn += "\n//throw "; + for (int i = 0; i < sExceptions.size(); i++){ + String sCurException = sExceptions.get(i); + if (sReturn.indexOf(sCurException) == -1){ + if (a++ > 0){ + sReturn += ", "; + } + sReturn += getObjectTypeDescription(sCurException, false); + + } + } + + } + sReturn += "{"; + return sReturn; + } + + + public boolean needsqueryInterface(){ + return true; + } + + + public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){ + return "\t" + _sReturnVariableName + "( " + _sIncomingObjectName + ", " + getCSSNameSpaceString() + "::uno::UNO_QUERY_THROW);\n"; + } + + + public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){ + String sFirstLine = "\t"; + String sReturnVariableName = _sReturnVariableName; + // e.g. uno::Any a = xPropSet->getPropertyValue( rtl::OUString( "DefaultContext" ) ); + String[] sVarDefinition = _sReturnVariableName.split("="); + if (sVarDefinition.length > 0){ + String sVariable = sVarDefinition[0]; + String[] sVarDeclaration = sVariable.split(" "); + if (sVarDeclaration.length > 0){ + sFirstLine += sReturnVariableName + ";\n"; + sReturnVariableName = sVarDeclaration[sVarDeclaration.length-1]; + } + } + String sObjectDescription = _sIncomingObjectName + "->getPropertyValue(" + getStringValue(_sPropertyName) + ")"; + String sSecondLine = "\t" + getConvertedSourceCodeValueOfObject(sReturnVariableName, sObjectDescription, _aTypeClass, _sTypeName) + ";"; + return sFirstLine + sSecondLine; + } + + + public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){ + return "\t" + _sReturnVariableDescription + " = " + _sObjectDescription + "->" + _sMember + ";"; + } + + + public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){ + return _sObjectDescription + " >>= " + _sReturnVariableName; + } + + + public String getStringValue(String _sValue){ + bIncludeStringHeader = true; + return "OUString(\"" + _sValue + "\")"; + } + + + public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){ + String sReturn = ""; + if (_bAsHeader){ + sReturn = _sClassName.replace('.', '/'); + } + else{ + String sModuleName = Introspector.getModuleName(_sClassName); + sModuleName = Introspector.getShortClassName(sModuleName); + sReturn = getCSSNameSpaceString() + "::" + sModuleName + "::" + Introspector.getShortClassName(_sClassName); + } + return sReturn; + } + + + public String getMethodTerminationSourceCode(){ + return "\n}"; + } + + public String getMethodSeparator(){ + return "->"; + } + + + public String castLiteral(String _sExpression, TypeClass _aTypeClass){ + String sReturn = ""; + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + case TypeClass.BYTE_value: + case TypeClass.DOUBLE_value: + case TypeClass.FLOAT_value: + case TypeClass.UNSIGNED_SHORT_value: + case TypeClass.SHORT_value: + case TypeClass.LONG_value: + case TypeClass.UNSIGNED_LONG_value: + case TypeClass.HYPER_value: + case TypeClass.UNSIGNED_HYPER_value: + sReturn = _sExpression; + break; + case TypeClass.CHAR_value: + sReturn = "'" + _sExpression + "'"; + break; + case TypeClass.STRING_value: + sReturn = getStringValue(_sExpression); + break; + case TypeClass.ENUM_value: + default: + sReturn = _sExpression; + System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'"); + } + return sReturn; + } + + public String getbooleanTypeDescription(){ + return "sal_Bool"; + } + + public String getbyteTypeDescription(){ + return "sal_Int8"; + } + + public String getshortTypeDescription(){ + return "sal_Int16"; + } + + public String getlongTypeDescription(){ + return "sal_Int32"; + } + + public String getunsignedlongTypeDescription(){ + return "sal_uInt32"; + } + + public String gethyperTypeDescription(){ + return "sal_Int64"; + } + + public String getunsignedhyperTypeDescription(){ + return "sal_uInt64"; + } + + public String getfloatTypeDescription(){ + return "float"; + } + + public String getdoubleTypeDescription(){ + return "double"; + } + + public String getcharTypeDescription(){ + return "sal_Unicode"; + } + + public String getstringTypeDescription(boolean _bAsHeaderSourceCode){ + bIncludeStringHeader = true; + if (_bAsHeaderSourceCode){ + return ""; + } + else{ + return "OUString"; + } + } + + public String getanyTypeDescription(boolean _bAsHeaderSourceCode){ + if (_bAsHeaderSourceCode){ + return "com/sun/star/uno/XInterface"; + } + else{ + return "XInterface"; + } + } + + + public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray, TypeClass _aTypeClass, boolean _bInitialize){ + boolean bIsPrimitive = Introspector.isPrimitive(_aTypeClass); + + String sReturn = ""; + if (bIsArray){ + bIncludeSequenceHeader = true; + sReturn = getCSSNameSpaceString() + "::uno::Sequence<" + _sTypeString + "> " + _sVariableName; + } + else{ + if (bIsPrimitive){ + sReturn = _sTypeString + " " + _sVariableName; + if (_bInitialize){ + switch (_aTypeClass.getValue()){ + case TypeClass.BOOLEAN_value: + sReturn = sReturn + " = false"; + break; + case TypeClass.BYTE_value: + case TypeClass.UNSIGNED_SHORT_value: + case TypeClass.SHORT_value: + case TypeClass.LONG_value: + case TypeClass.UNSIGNED_LONG_value: + case TypeClass.HYPER_value: + case TypeClass.UNSIGNED_HYPER_value: + sReturn = sReturn + " = 0"; + break; + case TypeClass.DOUBLE_value: + case TypeClass.FLOAT_value: + sReturn = sReturn + " = 0.0"; + break; + case TypeClass.CHAR_value: + sReturn = sReturn + "'0'"; + break; + case TypeClass.STRING_value: + sReturn = _sTypeString + " " + _sVariableName; + break; + default: + sReturn = _sTypeString + " " + _sVariableName; + System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'getVariableDeclaration()'"); + } + } + } + else{ + sReturn = getCSSNameSpaceString() + "::uno::Reference<" + _sTypeString + "> " +_sVariableName; + } + } + return sReturn; + } + + public String getCommentSign(){ + return "//"; + } + + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingDialogProvider.java b/odk/examples/java/Inspector/SwingDialogProvider.java new file mode 100644 index 000000000..e66bedce8 --- /dev/null +++ b/odk/examples/java/Inspector/SwingDialogProvider.java @@ -0,0 +1,444 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.uno.XComponentContext; +import java.awt.Component; +import java.awt.Container; +import java.awt.Dimension; +import java.awt.event.ActionListener; +import java.awt.event.ComponentAdapter; +import java.awt.event.ComponentEvent; +import java.awt.event.KeyEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import javax.swing.ButtonGroup; +import javax.swing.JDialog; +import javax.swing.JMenu; +import javax.swing.JMenuBar; +import javax.swing.JMenuItem; +import javax.swing.JPopupMenu; +import javax.swing.JRadioButtonMenuItem; +import javax.swing.JTabbedPane; +import javax.swing.KeyStroke; + + + +public class SwingDialogProvider implements XDialogProvider{ + + private JPopupMenu m_jPopupMenu = new JPopupMenu(); + private XComponentContext m_xComponentContext; + private Inspector._Inspector m_oInspector; + private JDialog m_jInspectorDialog = new JDialog(); + private JTabbedPane m_jTabbedPane1 = new JTabbedPane(); + private Container cp; + + private JMenu jMnuOptions = new JMenu("Options"); + private JRadioButtonMenuItem jJavaMenuItem = null; + private JRadioButtonMenuItem jCPlusPlusMenuItem = null; + private JRadioButtonMenuItem jBasicMenuItem = null; + + /** Creates a new instance of SwingPopupMentuProvider */ + public SwingDialogProvider(Inspector._Inspector _oInspector, String _sTitle) { + m_oInspector = _oInspector; + m_xComponentContext = _oInspector.getXComponentContext(); + insertMenus(); + initializePopupMenu(); + cp = m_jInspectorDialog.getContentPane(); + cp.setLayout(new java.awt.BorderLayout(0, 10)); + m_jTabbedPane1.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT); + m_jInspectorDialog.addWindowListener(new InspectorWindowAdapter()); + m_jInspectorDialog.addComponentListener(new InspectorComponentAdapter()); + m_jInspectorDialog.setTitle(_sTitle); + m_jInspectorDialog.setLocation(100, 50); + m_jInspectorDialog.getContentPane().add(m_jTabbedPane1); + } + + + + public JDialog getDialog(){ + return m_jInspectorDialog; + } + + + private void addMenuBar(JMenuBar _jMenuBar){ + getDialog().setJMenuBar(_jMenuBar); + } + + + private void removeTabPaneByIndex(int _nIndex){ + if (_nIndex > -1){ + String sSelInspectorPanelTitle = m_jTabbedPane1.getTitleAt(_nIndex); + m_jTabbedPane1.remove(_nIndex); + m_oInspector.getInspectorPages().remove(sSelInspectorPanelTitle); + } + } + + + public void selectInspectorPageByIndex(int nTabIndex){ + m_jTabbedPane1.setSelectedIndex(nTabIndex); + } + + + public int getInspectorPageCount(){ + return m_jTabbedPane1.getTabCount(); + } + + + public JTabbedPane getTabbedPane(){ + return m_jTabbedPane1; + } + + + public InspectorPane getSelectedInspectorPage(){ + int nIndex = m_jTabbedPane1.getSelectedIndex(); + return getInspectorPage(nIndex); + } + + + public InspectorPane getInspectorPage(int _nIndex){ + InspectorPane oInspectorPane = null; + if (_nIndex > -1){ + String sInspectorPanelTitle = m_jTabbedPane1.getTitleAt(_nIndex); + oInspectorPane = m_oInspector.getInspectorPages().get(sInspectorPanelTitle); + } + return oInspectorPane; + } + + + private void removeTabPanes(){ + int nCount = m_jTabbedPane1.getTabCount(); + if (nCount > 0){ + for (int i = nCount-1; i >= 0; i--){ + removeTabPaneByIndex(i); + } + } + } + + private void removeSelectedTabPane(){ + int nIndex = getTabbedPane().getSelectedIndex(); + removeTabPaneByIndex(nIndex); + } + + + private class InspectorComponentAdapter extends ComponentAdapter{ + @Override + public void componentHidden(ComponentEvent e){ + m_jInspectorDialog.pack(); + m_jInspectorDialog.invalidate(); + + } + + @Override + public void componentShown(ComponentEvent e){ + m_jInspectorDialog.pack(); + m_jInspectorDialog.invalidate(); + } + } + + private class InspectorWindowAdapter extends WindowAdapter{ + @Override + public void windowClosed(WindowEvent e){ + removeTabPanes(); + m_oInspector.disposeHiddenDocuments(); + } + + @Override + public void windowClosing(WindowEvent e){ + removeTabPanes(); + m_oInspector.disposeHiddenDocuments(); + } + } + + + + private void initializePopupMenu(){ + m_jPopupMenu.add(getInspectMenuItem("Inspect")); + m_jPopupMenu.add(getSourceCodeMenuItem(SADDTOSOURCECODE)); + m_jPopupMenu.add(getInvokeMenuItem(SINVOKE)); + m_jPopupMenu.addSeparator(); + m_jPopupMenu.add(getHelpMenuItem("Help")); + } + + + private void addOpenDocumentMenu(JMenu _jMnuRoot){ + ActionListener oActionListener = new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + String sTDocUrl = evt.getActionCommand(); + m_oInspector.inspectOpenDocument(sTDocUrl); + } + }; + String[] sTDocUrls = m_oInspector.getTDocUrls(); + String[] sTDocTitles = m_oInspector.getTDocTitles(sTDocUrls); + for (int i = 0; i < sTDocUrls.length; i++){ + addSingleMenuItem(_jMnuRoot, sTDocTitles[i], sTDocUrls[i], oActionListener); + } + } + + + private void addApplicationDocumentMenu(JMenu _jMnuRoot){ + ActionListener oActionListener = new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + String sApplicationDocUrl = evt.getActionCommand(); + m_oInspector.inspectOpenEmptyDocument(sApplicationDocUrl); + } + }; + String[][] sApplUrls = m_oInspector.getApplicationUrls(); + for (int i = 0; i < sApplUrls.length; i++){ + addSingleMenuItem(_jMnuRoot, sApplUrls[i][1], sApplUrls[i][0], oActionListener); + } + } + + + private void addSingleMenuItem(JMenu _jMnuOpenDocs, String _sTitle, String _sActionCommand, ActionListener _oActionListener){ + javax.swing.JMenuItem jMnuItemOpenDoc = new javax.swing.JMenuItem(_sTitle); + jMnuItemOpenDoc.setActionCommand(_sActionCommand); + jMnuItemOpenDoc.addActionListener(_oActionListener); + _jMnuOpenDocs.add(jMnuItemOpenDoc); + } + + + private void addHelpMenu(JMenuBar _jInspectMenuBar){ + JMenu jMnuHelp = new JMenu("Help"); + jMnuHelp.add(getHelpMenuItem("Idl-Help")); + _jInspectMenuBar.add(jMnuHelp); + } + + + private JMenuItem getHelpMenuItem(String _sMenuTitle){ + JMenuItem jMnuHelpItem = new JMenuItem(_sMenuTitle); + jMnuHelpItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0)); + jMnuHelpItem.setMnemonic('H'); + jMnuHelpItem.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.openIdlFileforSelectedNode(); + } + }); + return jMnuHelpItem; + } + + private void addFileMenu(JMenuBar _jInspectMenuBar){ + JMenu jMnuFile = new JMenu("File"); + JMenuItem jMnuItemRemoveInspector = new JMenuItem("Remove"); + jMnuItemRemoveInspector.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + removeSelectedTabPane(); + } + }); + jMnuFile.add(jMnuItemRemoveInspector); + JMenuItem jMnuItemExit = new JMenuItem("Exit"); + jMnuItemExit.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + getDialog().dispose(); + } + }); + jMnuFile.add(jMnuItemExit); + _jInspectMenuBar.add(jMnuFile); + } + + private JMenuItem getInspectMenuItem(String _sLabel){ + JMenuItem jMnuSelectedObject = new JMenuItem(_sLabel); + jMnuSelectedObject.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.inspectSelectedNode(); + } + }); + return jMnuSelectedObject; + } + + + private JMenuItem getSourceCodeMenuItem(String _sLabel){ + JMenuItem jMnuSelectedObject = new JMenuItem(_sLabel); + jMnuSelectedObject.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.addSourceCodeOfSelectedNode(); + } + }); + return jMnuSelectedObject; + } + + private JMenuItem getInvokeMenuItem(String _sLabel){ + JMenuItem jMnuSelectedObject = new JMenuItem(_sLabel); + jMnuSelectedObject.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.invokeSelectedMethod(); + } + }); + return jMnuSelectedObject; + } + + + private void addInspectMenu(JMenuBar _jInspectMenuBar){ + JMenu jMnuInspect = new JMenu("Inspect"); + addApplicationDocumentMenu(jMnuInspect); + jMnuInspect.addSeparator(); + addGlobalServiceManagerMenu(jMnuInspect); + jMnuInspect.addSeparator(); + jMnuInspect.add(getInspectMenuItem("Selected Object")); + jMnuInspect.addSeparator(); + addOpenDocumentMenu(jMnuInspect); + _jInspectMenuBar.add(jMnuInspect); + } + + public int getLanguage(){ + return XLanguageSourceCodeGenerator.nJAVA; + } + + + public void selectSourceCodeLanguage(int _nLanguage){ + switch (_nLanguage){ + case XLanguageSourceCodeGenerator.nJAVA: + jJavaMenuItem.setSelected(true); + break; + case XLanguageSourceCodeGenerator.nCPLUSPLUS: + jCPlusPlusMenuItem.setSelected(true); + break; + case XLanguageSourceCodeGenerator.nBASIC: + jBasicMenuItem.setSelected(true); + break; + default: + System.out.println("Warning: Sourcecode language is not defined!"); + } + } + + private JRadioButtonMenuItem addLanguageMenuItem(ButtonGroup _group, String _sLanguageTitle, boolean _bSelect, char _sMnemonic, final int _nLanguage){ + JRadioButtonMenuItem jMenuItem = new JRadioButtonMenuItem(_sLanguageTitle, _bSelect); + jMenuItem.setMnemonic(_sMnemonic); + _group.add(jMenuItem); + jMenuItem.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.setSourceCodeLanguage(_nLanguage); + } + }); + return jMenuItem; + } + + + public String getIDLPath(){ + return this.m_oInspector.getIDLPath(); + } + + private void addOptionsMenu(JMenuBar _jInspectMenuBar){ + ButtonGroup oButtonGroup = new ButtonGroup(); + jJavaMenuItem = addLanguageMenuItem(oButtonGroup, "Generate Java Sourcecode", true, 'J', XLanguageSourceCodeGenerator.nJAVA); + jMnuOptions.add(jJavaMenuItem); + jCPlusPlusMenuItem = addLanguageMenuItem(oButtonGroup, "Generate C++ Sourcecode", false, 'C', XLanguageSourceCodeGenerator.nCPLUSPLUS); + jMnuOptions.add(jCPlusPlusMenuItem); + jBasicMenuItem = addLanguageMenuItem(oButtonGroup, "Generate OpenOffice.org Basic Sourcecode", false, 'B', XLanguageSourceCodeGenerator.nBASIC); + jMnuOptions.add(jBasicMenuItem); + jMnuOptions.addSeparator(); + JMenuItem jMenuItem = new JMenuItem("Path to SDK-Installation"); + jMenuItem.setMnemonic('I'); + jMenuItem.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.assignSDKPath(); + } + }); + + jMnuOptions.add(jMenuItem); + _jInspectMenuBar.add(jMnuOptions); + } + + + private void insertMenus(){ + JMenuBar jMenuBar1 = new javax.swing.JMenuBar(); + addFileMenu(jMenuBar1); + addInspectMenu(jMenuBar1); + JMenu jMnuEdit = new JMenu("Edit"); + JMenu jMnuView = new JMenu("View"); + addOptionsMenu(jMenuBar1); + jMenuBar1.setFont(new java.awt.Font("Dialog", 0, 12)); + jMenuBar1.add(jMnuEdit); + jMenuBar1.add(jMnuView); + addHelpMenu(jMenuBar1); + addMenuBar(jMenuBar1); + } + + private void addGlobalServiceManagerMenu(JMenu _jMnuRoot){ + JMenuItem jMnuGlobalServiceManager = new JMenuItem("Global Service Manager"); + jMnuGlobalServiceManager.addActionListener(new ActionListener(){ + public void actionPerformed(java.awt.event.ActionEvent evt) { + m_oInspector.inspect(m_xComponentContext.getServiceManager(), "Global ServiceManager"); + } + }); + _jMnuRoot.add(jMnuGlobalServiceManager); + } + + + + public void enablePopupMenuItem(String _sMenuTitle, boolean _bdoEnable){ + Component[] oComponents = m_jPopupMenu.getComponents(); + for (int i = 0; i < oComponents.length; i++){ + if (oComponents[i] instanceof JMenuItem){ + JMenuItem jMenuItem = (JMenuItem) oComponents[i]; + if (jMenuItem.getText().equals(_sMenuTitle)){ + jMenuItem.setEnabled(_bdoEnable); + } + } + } + } + + + public void showPopUpMenu(Object _invoker, int x, int y) throws ClassCastException{ + if (_invoker instanceof Component){ + m_jPopupMenu.show((Component) _invoker, x, y); + } + } + + + public void show(int _nPageIndex){ + Dimension aDimension = m_jInspectorDialog.getSize(); + selectInspectorPageByIndex(_nPageIndex); + if (_nPageIndex > 0){ + m_jInspectorDialog.setSize(aDimension); + } + else{ + m_jInspectorDialog.pack(); + } + m_jInspectorDialog.setVisible(true); + } + + public void paint(){ + m_jTabbedPane1.paintImmediately(m_jTabbedPane1.getBounds()); + } + + + public void addInspectorPage(String _sTitle, Object _oContainer) throws ClassCastException{ + if (_oContainer instanceof Component){ + m_jTabbedPane1.addTab(_sTitle, (Component) _oContainer); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingTreeControlProvider.java b/odk/examples/java/Inspector/SwingTreeControlProvider.java new file mode 100644 index 000000000..c8cbb4dcb --- /dev/null +++ b/odk/examples/java/Inspector/SwingTreeControlProvider.java @@ -0,0 +1,423 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.beans.Property; +import com.sun.star.beans.PropertyValue; +import com.sun.star.lang.NullPointerException; +import com.sun.star.reflection.XConstantTypeDescription; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.Type; +import java.awt.BorderLayout; +import java.awt.Container; +import java.awt.Dimension; +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import javax.swing.JPanel; +import javax.swing.JScrollBar; +import javax.swing.JScrollPane; +import javax.swing.JSplitPane; +import javax.swing.JTextArea; +import javax.swing.JTextField; +import javax.swing.JTree; +import javax.swing.event.TreeSelectionEvent; +import javax.swing.event.TreeSelectionListener; +import javax.swing.event.TreeWillExpandListener; +import javax.swing.tree.DefaultTreeSelectionModel; +import javax.swing.tree.ExpandVetoException; +import javax.swing.tree.TreePath; +import javax.swing.tree.TreeSelectionModel; + + + +public class SwingTreeControlProvider implements XTreeControlProvider{ + private JTextArea jtxtGeneratedSourceCode = new JTextArea(); + private JTextField jtxtFilter = new JTextField(); + private javax.swing.JLabel jlblFilter = new javax.swing.JLabel("Set a filter"); + private JTree jTree = new javax.swing.JTree(); + private XDialogProvider m_xDialogProvider; + private HideableTreeModel treeModel; + private InspectorPane m_oInspectorPane; + private Object oUserDefinedObject = null; + private boolean bIsUserDefined = false; + private SwingUnoNode oRootNode; + + private final int nDIALOGWIDTH = 800; + + + + public SwingTreeControlProvider(XDialogProvider _xDialogProvider){ + m_xDialogProvider = _xDialogProvider; + } + + + public void addInspectorPane(InspectorPane _oInspectorPane){ + m_oInspectorPane = _oInspectorPane; + } + + public InspectorPane getInspectorPane() throws NullPointerException{ + if (m_oInspectorPane == null){ + throw new NullPointerException("InspectorPage has not been added to TreeControl"); + } + else{ + return m_oInspectorPane; + } + } + + private void ComponentSelector(Object _oRootObject, String _sRootTreeNodeName) { + oRootNode = new SwingUnoNode(_oRootObject); + oRootNode.setLabel(_sRootTreeNodeName); + treeModel = new HideableTreeModel(oRootNode); + jTree.setModel(treeModel); + jTree.setRootVisible(true); + jTree.setVisible(true); + oRootNode.setFoldable(true); + enableFilterElements(null); + } + + + + private void insertTopPanel(JPanel _jPnlCenter){ + javax.swing.JPanel jPnlTop = new javax.swing.JPanel(new BorderLayout(10, 10)); + jPnlTop.setPreferredSize(new java.awt.Dimension(nDIALOGWIDTH, 20)); + jlblFilter.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT); + jlblFilter.setHorizontalTextPosition(javax.swing.SwingConstants.RIGHT); + jPnlTop.add(jlblFilter, java.awt.BorderLayout.WEST); + jtxtFilter.setHorizontalAlignment(javax.swing.JTextField.LEFT); + jtxtFilter.setPreferredSize(new java.awt.Dimension(200, 10)); + jtxtFilter.addKeyListener(new InspectorKeyFilterAdapter()); + jPnlTop.add(jtxtFilter, java.awt.BorderLayout.CENTER); + _jPnlCenter.add(jPnlTop, java.awt.BorderLayout.NORTH); + } + + + private void insertBottomPanel(JSplitPane _jSplitPane){ //JPanel _jPnlCenter){ + jtxtGeneratedSourceCode.setTabSize(4); + jtxtGeneratedSourceCode.getAccessibleContext().setAccessibleName("generated SourceCode"); + JScrollPane jScrollPane = new JScrollPane(jtxtGeneratedSourceCode); + jScrollPane.setPreferredSize(new Dimension(nDIALOGWIDTH,205)); + jtxtGeneratedSourceCode.setEditable(false); + _jSplitPane.setBottomComponent(jScrollPane); + } + + private void insertBorderPanes(Container _cp){ + JPanel jPnlEast = new JPanel(new BorderLayout()); + JPanel jPnlNorth = new JPanel(new BorderLayout()); + JPanel jPnlSouth = new JPanel(new BorderLayout()); + JPanel jPnlWest = new JPanel(new BorderLayout()); + _cp.add(jPnlNorth, java.awt.BorderLayout.NORTH); + jPnlWest.setPreferredSize(new java.awt.Dimension(10, 10)); + _cp.add(jPnlWest, java.awt.BorderLayout.WEST); + jPnlEast.setPreferredSize(new java.awt.Dimension(10, 10)); + _cp.add(jPnlEast, java.awt.BorderLayout.EAST); + jPnlSouth.setPreferredSize(new java.awt.Dimension(10, 10)); + _cp.add(jPnlSouth, java.awt.BorderLayout.SOUTH); + } + + + public String enableFilterElements(XUnoNode _oUnoNode){ + String sFilter =""; + boolean bIsFacetteNode = isFacetteNode(_oUnoNode); + this.jtxtFilter.setEnabled(bIsFacetteNode); + this.jlblFilter.setEnabled(bIsFacetteNode); + sFilter = m_oInspectorPane.getFilter(_oUnoNode); + jtxtFilter.setText(sFilter); + return sFilter; + } + + + private class InspectorKeyFilterAdapter extends KeyAdapter{ + @Override + public void keyReleased(KeyEvent e){ + String sFilter = jtxtFilter.getText(); + SwingTreePathProvider oSwingTreePathProvider = new SwingTreePathProvider(jTree.getSelectionPath()); + XUnoNode oUnoNode = oSwingTreePathProvider.getLastPathComponent(); + if (oUnoNode instanceof XUnoFacetteNode){ + m_oInspectorPane.applyFilter((XUnoFacetteNode) oUnoNode, sFilter); + } + } + } + + + + /** Inspect the given object for methods, properties, interfaces, and + * services. + * @param _oUserDefinedObject The object to inspect + * @throws RuntimeException If + */ + public Object inspect(java.lang.Object _oUserDefinedObject, String _sTitle) throws com.sun.star.uno.RuntimeException { + JPanel jPnlContainer = new javax.swing.JPanel(new BorderLayout(10, 10)); + try { + javax.swing.JPanel jPnlCenter = new javax.swing.JPanel(); + bIsUserDefined = (_oUserDefinedObject != null); + if (bIsUserDefined){ + oUserDefinedObject = _oUserDefinedObject; + m_oInspectorPane.setTitle(_sTitle); + } + javax.swing.JScrollPane jScrollPane1 = new javax.swing.JScrollPane(); + TreeSelectionModel tsm = new DefaultTreeSelectionModel(); + tsm.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); + jTree.setSelectionModel(tsm); + jTree.setVisible(false); + jPnlCenter.setLayout(new java.awt.BorderLayout(10, 10)); + jPnlCenter.getAccessibleContext().setAccessibleName("inspection tab view"); + insertTopPanel(jPnlCenter); + jScrollPane1.setViewportView(jTree); + jScrollPane1.setPreferredSize(new java.awt.Dimension(600, 600)); + jScrollPane1.getAccessibleContext().setAccessibleName("API view scroll pane"); + + JScrollBar jHScrollBar = jScrollPane1.createHorizontalScrollBar(); + jHScrollBar.getAccessibleContext().setAccessibleName("API view horizontal scroll bar"); + jScrollPane1.setHorizontalScrollBar(jHScrollBar); + + JScrollBar jVScrollBar = jScrollPane1.createVerticalScrollBar(); + jVScrollBar.getAccessibleContext().setAccessibleName("API view vertical scroll bar"); + jScrollPane1.setVerticalScrollBar(jVScrollBar); + + JSplitPane jSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT); + jSplitPane.setTopComponent(jScrollPane1); + jPnlCenter.add(jSplitPane, java.awt.BorderLayout.CENTER); + jSplitPane.setDividerLocation(500); + insertBottomPanel(jSplitPane); + UnoTreeRenderer oUnoTreeRenderer = new UnoTreeRenderer(); + jTree.setCellRenderer(oUnoTreeRenderer); + jTree.addTreeSelectionListener( + new TreeSelectionListener() { + public void valueChanged(TreeSelectionEvent event) { + TreePath tp = event.getNewLeadSelectionPath(); + if (tp != null){ + XUnoNode oUnoNode = getSelectedNode(); + String sFilter = enableFilterElements(oUnoNode); + } + } + } + ); + // Add KeyListener for help + jTree.addKeyListener( new java.awt.event.KeyAdapter() { + @Override + public void keyReleased(java.awt.event.KeyEvent event) { + if ( event.getKeyCode() == KeyEvent.VK_F1 ) { + // function key F1 pressed + TreePath aTreePath = jTree.getSelectionPath(); + SwingUnoNode oUnoNode = (SwingUnoNode) aTreePath.getLastPathComponent(); + oUnoNode.openIdlDescription(m_xDialogProvider.getIDLPath()); + } + } + }); + jTree.addMouseListener(new MouseAdapter() { + @Override + public void mousePressed (MouseEvent e) { + if (e.isPopupTrigger()){ + m_oInspectorPane.showPopUpMenu(e.getComponent(), e.getX(), e.getY()); + } + //unfortunately under Windows the method "isPopupTrigger" always returns false + else if ((e.getModifiersEx() & MouseEvent.BUTTON3_DOWN_MASK) == MouseEvent.BUTTON3_DOWN_MASK){ + m_oInspectorPane.showPopUpMenu(e.getComponent(), e.getX(), e.getY()); + } + } + }); + jPnlContainer.add(jPnlCenter, java.awt.BorderLayout.CENTER); + insertBorderPanes(jPnlContainer); + if (this.bIsUserDefined){ + ComponentSelector(oUserDefinedObject, m_oInspectorPane.getTitle()); + } + m_xDialogProvider.addInspectorPage(m_oInspectorPane.getTitle(), jPnlContainer); + addTreeExpandListener(); + } + catch( Exception exception ) { + exception.printStackTrace(System.err); + } + return jPnlContainer; + } + + public HideableTreeModel getModel(){ + return treeModel; + } + + + public void addTreeExpandListener(){ + jTree.addTreeWillExpandListener( + new TreeWillExpandListener() { + public void treeWillExpand(javax.swing.event.TreeExpansionEvent event) throws javax.swing.tree.ExpandVetoException { + SwingTreePathProvider oSwingTreePathProvider = new SwingTreePathProvider(event.getPath()); + XUnoNode oUnoNode = oSwingTreePathProvider.getLastPathComponent(); + if (!m_oInspectorPane.expandNode(oUnoNode)){ + throw new ExpandVetoException(event); + } + } + + public void treeWillCollapse( javax.swing.event.TreeExpansionEvent evt) throws javax.swing.tree.ExpandVetoException { + } + }); + } + + + public void setSourceCode(String _sSourceCode){ + jtxtGeneratedSourceCode.setText(_sSourceCode); + } + + + public XTreePathProvider getSelectedPath(){ + return new SwingTreePathProvider(jTree.getSelectionPath()); + } + + + public void expandPath(XTreePathProvider _xTreePathProvider) throws ClassCastException{ + SwingTreePathProvider oSwingTreePathProvider = (SwingTreePathProvider) _xTreePathProvider; + jTree.expandPath(oSwingTreePathProvider.getSwingTreePath()); + } + + + public XUnoNode getSelectedNode(){ + XUnoNode oUnoNode = null; + TreePath aTreePath = jTree.getSelectionPath(); + Object oNode = aTreePath.getLastPathComponent(); + if (oNode instanceof XUnoNode){ + oUnoNode = (XUnoNode) oNode; + } + return oUnoNode; + } + + + public void nodeInserted(XUnoNode _oParentNode, XUnoNode _oChildNode, int index) { + getModel().nodeInserted(_oParentNode, _oChildNode, _oParentNode.getChildCount()-1); + } + + + public void nodeChanged(XUnoNode _oNode) { + getModel().nodeChanged(_oNode); + } + + + public boolean setNodeVisible(Object node, boolean v) { + return getModel().setNodeVisible(node, v); + } + + + public boolean isPropertyNode(XUnoNode _oUnoNode){ + return (_oUnoNode instanceof SwingUnoPropertyNode); + } + + + public boolean isMethodNode(XUnoNode _oUnoNode){ + return (_oUnoNode instanceof SwingUnoMethodNode); + } + + + public boolean isFacetteNode(XUnoNode _oUnoNode){ + return (_oUnoNode instanceof SwingUnoFacetteNode); + } + + + public XUnoNode addUnoNode(Object _oUnoObject){ + return new SwingUnoNode(_oUnoObject); + } + + + public XUnoNode addUnoNode(Object _oUnoObject, Type _aType){ + return new SwingUnoNode(_oUnoObject, _aType); + } + + + public XUnoFacetteNode addUnoFacetteNode(XUnoNode _oParentNode, String _sNodeDescription, Object _oUnoObject){ + SwingUnoFacetteNode oSwingUnoFacetteNode = new SwingUnoFacetteNode(_oUnoObject); + oSwingUnoFacetteNode.setLabel(_sNodeDescription); + if (_oParentNode != null){ + ((SwingUnoNode) _oParentNode).addChildNode(oSwingUnoFacetteNode); + } + return oSwingUnoFacetteNode; + } + + + public XUnoMethodNode addMethodNode(Object _objectElement, XIdlMethod _xIdlMethod){ + SwingUnoMethodNode oSwingUnoMethodNode = new SwingUnoMethodNode(_xIdlMethod, _objectElement, m_xDialogProvider); + return oSwingUnoMethodNode; + } + + + public XUnoPropertyNode addUnoPropertyNodeWithName(Property _aProperty){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aProperty); + oUnoPropertyNode.setLabel("Name: " + _aProperty.Name); + return oUnoPropertyNode; + } + + + public XUnoPropertyNode addUnoPropertyNodeWithHandle(Property _aProperty){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aProperty); + oUnoPropertyNode.setLabel("Handle: " + _aProperty.Handle); + return oUnoPropertyNode; + } + + + public XUnoPropertyNode addUnoPropertyNodeWithType(Property _aProperty){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aProperty); + oUnoPropertyNode.setLabel("Type: " + _aProperty.Type.getTypeName()); + return oUnoPropertyNode; + } + + + public XUnoPropertyNode addUnoPropertyNodeWithAttributesDescription(Property _aProperty){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aProperty); + XConstantTypeDescription[] xPropertyAttributesTypeDescriptions = Introspector.getIntrospector().getFieldsOfConstantGroup("com.sun.star.beans.PropertyAttribute"); + String sDisplay = Introspector.getIntrospector().getConstantDisplayString(_aProperty.Attributes, xPropertyAttributesTypeDescriptions, "Attributes: "); + oUnoPropertyNode.setLabel(sDisplay); + return oUnoPropertyNode; + } + + + public XUnoPropertyNode addUnoPropertyNode(Object _oUnoObject, Property _aProperty){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aProperty, _oUnoObject, null); + oUnoPropertyNode.setPropertyNodeType(XUnoPropertyNode.nPROPERTYSETINFOTYPE); + oUnoPropertyNode.setLabel(UnoPropertyNode.getStandardPropertyDescription(_aProperty, null)); + return oUnoPropertyNode; + } + + + public XUnoPropertyNode addUnoPropertyNode(Object _oUnoObject, Property _aProperty, Object _oUnoReturnObject){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aProperty, _oUnoObject, _oUnoReturnObject); + oUnoPropertyNode.setLabel(UnoPropertyNode.getStandardPropertyDescription(_aProperty, _oUnoReturnObject)); + return oUnoPropertyNode; + } + + + public XUnoPropertyNode addUnoPropertyNode(Object _oUnoObject, PropertyValue _aPropertyValue, Object _oReturnObject){ + SwingUnoPropertyNode oUnoPropertyNode = new SwingUnoPropertyNode(_aPropertyValue, _oUnoObject, _oReturnObject); + oUnoPropertyNode.setLabel(UnoPropertyNode.getStandardPropertyValueDescription(_aPropertyValue)); + return oUnoPropertyNode; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingTreePathProvider.java b/odk/examples/java/Inspector/SwingTreePathProvider.java new file mode 100644 index 000000000..c0f6703ca --- /dev/null +++ b/odk/examples/java/Inspector/SwingTreePathProvider.java @@ -0,0 +1,60 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +import javax.swing.tree.TreePath; + +public class SwingTreePathProvider implements XTreePathProvider { + private TreePath m_aTreePath; + + /** Creates a new instance of TreePathProvider */ + public SwingTreePathProvider(TreePath _aTreePath) { + m_aTreePath = _aTreePath; + } + + + public XUnoNode getLastPathComponent(){ + return (XUnoNode) m_aTreePath.getLastPathComponent(); + } + + + public XUnoNode getPathComponent(int i){ + return (XUnoNode) m_aTreePath.getPathComponent(i); + } + + public int getPathCount(){ + return m_aTreePath.getPathCount(); + } + + + public XTreePathProvider getParentPath(){ + return new SwingTreePathProvider(m_aTreePath.getParentPath()); + } + + + public XTreePathProvider pathByAddingChild(XUnoNode _oUnoNode){ + TreePath aTreePath = m_aTreePath.pathByAddingChild(_oUnoNode); + return new SwingTreePathProvider(aTreePath); + } + + public TreePath getSwingTreePath(){ + return m_aTreePath; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingUnoFacetteNode.java b/odk/examples/java/Inspector/SwingUnoFacetteNode.java new file mode 100644 index 000000000..31a80ffd9 --- /dev/null +++ b/odk/examples/java/Inspector/SwingUnoFacetteNode.java @@ -0,0 +1,84 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + + + +public class SwingUnoFacetteNode extends SwingUnoNode implements XUnoFacetteNode{ + private String m_sFilter = ""; + + /** Creates a new instance of UnoMethodNode */ + public SwingUnoFacetteNode(Object _oUnoObject){ + super(_oUnoObject); + setFoldable(true); + } + + + public String getFilter(){ + return m_sFilter; + } + + public void setFilter(String _sFilter){ + m_sFilter = _sFilter; + } + + @Override + public String getName(){ + return toString(); + } + +// TODO The implementation of the following methods is not really robust and should be changed!!! + public boolean isMethodNode(){ + return ((String) getUserObject()).equals(SMETHODDESCRIPTION); + } + + public boolean isPropertyNode(){ + String sNodeDescription = (String) getUserObject(); + return ((sNodeDescription.equals(SPROPERTYDESCRIPTION)) || (sNodeDescription.equals(SPROPERTYINFODESCRIPTION)) || (sNodeDescription.equals(SPROPERTYVALUEDESCRIPTION))); + } + + public boolean isContainerNode(){ + return ((String) getUserObject()).equals(SCONTAINERDESCRIPTION); + } + + public boolean isServiceNode(){ + return ((String) getUserObject()).equals(SSERVICEDESCRIPTION); + } + + public boolean isInterfaceNode(){ + return ((String) getUserObject()).equals(SINTERFACEDESCRIPTION); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingUnoMethodNode.java b/odk/examples/java/Inspector/SwingUnoMethodNode.java new file mode 100644 index 000000000..f06f2161c --- /dev/null +++ b/odk/examples/java/Inspector/SwingUnoMethodNode.java @@ -0,0 +1,144 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.ArrayList; + +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.TypeClass; + + + +public class SwingUnoMethodNode extends SwingUnoNode implements ActionListener, XUnoMethodNode{ + + private UnoMethodNode m_oUnoMethodNode; + private XDialogProvider m_xDialogProvider = null; + + public SwingUnoMethodNode(XIdlMethod _xIdlMethod, Object _oUnoObject, XDialogProvider _xDialogProvider) { + super(_oUnoObject); + m_oUnoMethodNode = new UnoMethodNode(_xIdlMethod, _oUnoObject, this); + m_xDialogProvider = _xDialogProvider; + setUserObject(m_oUnoMethodNode.getNodeDescription()); + if (m_oUnoMethodNode.isFoldable()){ + setFoldable(true); + } + } + + public boolean isFoldable(){ + return m_oUnoMethodNode.isFoldable(); + } + + @Override + public String getName(){ + return m_oUnoMethodNode.getName(); + } + + @Override + public String getClassName(){ + String sClassName = ""; + sClassName = getXIdlMethod().getDeclaringClass().getName(); + if (sClassName.equals("")){ + sClassName = super.getClassName(); + } + return sClassName; + } + + @Override + public String getAnchor(){ + return m_oUnoMethodNode.getAnchor(); + } + + public Object invoke(Object _oUnoObject, Object[] _oParameters) throws com.sun.star.uno.Exception{ + return m_oUnoMethodNode.invoke(_oUnoObject, _oParameters); + } + + + public Object[] getLastParameterObjects(){ + return m_oUnoMethodNode.getLastParameterObjects(); + } + + public Object getLastUnoReturnObject(){ + return m_oUnoMethodNode.getLastUnoReturnObject(); + } + + public TypeClass getTypeClass() { + return m_oUnoMethodNode.getTypeClass(); + } + + public XIdlMethod getXIdlMethod() { + return m_oUnoMethodNode.getXIdlMethod(); + } + + public boolean hasParameters() { + return m_oUnoMethodNode.hasParameters(); + } + + public Object invoke() throws com.sun.star.uno.Exception{ + return m_oUnoMethodNode.invoke(); + } + + public boolean isInvoked() { + return m_oUnoMethodNode.isInvoked(); + } + + public boolean isInvokable(){ + return m_oUnoMethodNode.isInvokable(); + } + + public boolean isPrimitive() { + return m_oUnoMethodNode.isPrimitive(); + } + + public void actionPerformed(ActionEvent e){ + openIdlDescription(m_xDialogProvider.getIDLPath()); + } + + public ArrayList<Object> getMethodObjects(){ + MethodParametersDialog oMethodParametersDialog = new MethodParametersDialog(this); + oMethodParametersDialog.addActionListener(this); + return oMethodParametersDialog.getMethodObjects(); + } + + + public String getParameterDescription(){ + return m_oUnoMethodNode.getParameterDescription(); + } + + + public String getStandardMethodDescription(){ + return m_oUnoMethodNode.getStandardMethodDescription(); + } +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingUnoNode.java b/odk/examples/java/Inspector/SwingUnoNode.java new file mode 100644 index 000000000..c1d84d85e --- /dev/null +++ b/odk/examples/java/Inspector/SwingUnoNode.java @@ -0,0 +1,160 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import com.sun.star.uno.Type; +import javax.swing.tree.TreeNode; + + +public class SwingUnoNode extends HideableMutableTreeNode implements XUnoNode{ + private UnoNode m_oUnoNode; + + /** Creates a new instance of SwingUnoNode */ + public SwingUnoNode(Object _oUnoObject) { + super(); + m_oUnoNode = new UnoNode(_oUnoObject); + } + + + public SwingUnoNode(Object _oUnoObject, Type _aType) { + super(); + m_oUnoNode = new UnoNode(_oUnoObject, _aType); + if (_aType != null){ + this.setLabel(_aType.getTypeName()); + } + } + + + public Object getUnoObject(){ + return m_oUnoNode.getUnoObject(); + } + + public void setVisible(String _sFilter){ + boolean bisVisible = isFilterApplicable(_sFilter); + super.setVisible(bisVisible); + } + + public boolean isFilterApplicable(String _sFilter) { + return m_oUnoNode.isFilterApplicable(_sFilter, getName()); + } + + public void setParameterObjects(Object[] _oParamObjects) { + m_oUnoNode.setParameterObjects(_oParamObjects); + } + + public void openIdlDescription(String _SDKPath) { + m_oUnoNode.openIdlDescription(_SDKPath, getClassName()); + } + + public Object[] getParameterObjects() { + return m_oUnoNode.getParameterObjects(); + } + + public String getClassName(){ + String sClassName = m_oUnoNode.getClassName(); + if (sClassName.equals("")){ + TreeNode oTreeNode = getParent(); + if (oTreeNode != null){ + if (oTreeNode instanceof XUnoNode){ + SwingUnoNode oUnoNode = (SwingUnoNode) oTreeNode; + sClassName = oUnoNode.getClassName(); + } + } + } + return sClassName; + } + + public String getAnchor() { + return m_oUnoNode.getAnchor(); + } + + + public void setFoldable(boolean _bIsFoldable){ + if (_bIsFoldable){ + addDummyNode(); + } + else{ + removeDummyNode(); + } + } + + + public XUnoNode getParentNode(){ + return (SwingUnoNode) super.getParent(); + } + + + public void addChildNode(XUnoNode _xUnoNode) { + super.add((SwingUnoNode) _xUnoNode); + } + + public void setLabel(String _sLabel){ + super.setUserObject(_sLabel); + this.m_oUnoNode.setLabel(_sLabel); + } + + public String getLabel(){ + return (String) super.getUserObject(); + } + + + @Override + public int getChildCount(){ + return super.getChildCount(); + } + + + public XUnoNode getChild(int _i){ + return (SwingUnoNode) super.getChildAt(_i); + } + + public int getNodeType(){ + return m_oUnoNode.getNodeType(); + } + + public void setNodeType(int _nNodeType){ + m_oUnoNode.setNodeType(_nNodeType); + } + + + public String getName(){ + return getClassName(); + } + + + public Type getUnoType(){ + return m_oUnoNode.getUnoType(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/SwingUnoPropertyNode.java b/odk/examples/java/Inspector/SwingUnoPropertyNode.java new file mode 100644 index 000000000..0e65a0361 --- /dev/null +++ b/odk/examples/java/Inspector/SwingUnoPropertyNode.java @@ -0,0 +1,102 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import com.sun.star.beans.Property; +import com.sun.star.beans.PropertyValue; + +public class SwingUnoPropertyNode extends SwingUnoNode implements XUnoPropertyNode{ + + private UnoPropertyNode m_oUnoPropertyNode = null; + + + public SwingUnoPropertyNode(Property _aProperty, Object _oUnoObject, Object _oUnoReturnObject) { + super(_oUnoObject); + m_oUnoPropertyNode = new UnoPropertyNode(_aProperty, _oUnoObject, _oUnoReturnObject); + super.setUserObject(m_oUnoPropertyNode.getLabel()); + setFoldable(m_oUnoPropertyNode.isFoldable()); + } + + + public SwingUnoPropertyNode(Property _aProperty){ + super(null); + m_oUnoPropertyNode = new UnoPropertyNode(_aProperty); + } + + + public SwingUnoPropertyNode(PropertyValue _aPropertyValue, Object _oUnoObject, Object _oUnoReturnObject) { + super(_oUnoObject); + m_oUnoPropertyNode = new UnoPropertyNode(_aPropertyValue, _oUnoObject, _oUnoReturnObject); + } + + @Override + public String getName(){ + return m_oUnoPropertyNode.getName(); + } + + + public Object getUnoReturnObject(){ + return m_oUnoPropertyNode.getUnoReturnObject(); + } + + + @Override + public String getClassName(){ + String sClassName = m_oUnoPropertyNode.getClassName(); + if (sClassName.equals("")){ + sClassName = super.getClassName(); + } + return sClassName; + } + + @Override + public String getAnchor(){ + return m_oUnoPropertyNode.getAnchor(); + } + + public int getPropertyNodeType(){ + return m_oUnoPropertyNode.getPropertyNodeType(); + } + + + public void setPropertyNodeType(int _nPropertyType){ + m_oUnoPropertyNode.setPropertyNodeType(_nPropertyType); + } + + public Property getProperty(){ + return m_oUnoPropertyNode.getProperty(); + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/TDocSupplier.java b/odk/examples/java/Inspector/TDocSupplier.java new file mode 100644 index 000000000..593c8a852 --- /dev/null +++ b/odk/examples/java/Inspector/TDocSupplier.java @@ -0,0 +1,166 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.beans.Property; +import com.sun.star.beans.PropertyValue; +import com.sun.star.frame.XComponentLoader; +import com.sun.star.frame.XModel; +import com.sun.star.lang.XComponent; +import com.sun.star.lang.XMultiComponentFactory; +import com.sun.star.sdbc.XRow; +import com.sun.star.ucb.Command; +import com.sun.star.ucb.UniversalContentBroker; +import com.sun.star.ucb.XCommandProcessor; +import com.sun.star.ucb.XContent; +import com.sun.star.ucb.XContentIdentifier; +import com.sun.star.ucb.XSimpleFileAccess; +import com.sun.star.ucb.XUniversalContentBroker; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; +import javax.swing.JOptionPane; + + +public class TDocSupplier { + private XMultiComponentFactory m_xMultiComponentFactory; + private XComponentContext m_xComponentContext; + + + /** Creates a new instance of TDocSupplier */ + public TDocSupplier(XComponentContext _xComponentContext) { + m_xComponentContext = _xComponentContext; + m_xMultiComponentFactory = m_xComponentContext.getServiceManager(); + } + + + private XComponentContext getXComponentContext(){ + return m_xComponentContext; + } + + + private XMultiComponentFactory getXMultiComponentFactory(){ + return m_xMultiComponentFactory; + } + + public XModel getXModelByTDocUrl(String _sTDocUrl){ + try{ + XRow xRow = getXRowOfTDocUrl(_sTDocUrl, "DocumentModel"); + if (xRow != null){ + Object oModel = xRow.getObject(1, null); + XModel xModel = UnoRuntime.queryInterface(XModel.class, oModel); + return xModel; + } + }catch(Exception exception){ + exception.printStackTrace(System.err); + } + JOptionPane.showMessageDialog(new javax.swing.JFrame(), "The selected Document could not be opened!", "Object Inspector", JOptionPane.ERROR_MESSAGE); + return null; + } + + + public String getTitleByTDocUrl(String _sTDocUrl){ + try{ + XRow xRow = this.getXRowOfTDocUrl(_sTDocUrl, "Title"); + if (xRow != null){ + return xRow.getString(1); + } + }catch(Exception exception){ + exception.printStackTrace(System.err); + } + JOptionPane.showMessageDialog(new javax.swing.JFrame(), "The selected Document could not be opened!", "Object Inspector", JOptionPane.ERROR_MESSAGE); + return ""; + } + + + private XRow getXRowOfTDocUrl(String _sTDocUrl, String _sPropertyName){ + try{ + XUniversalContentBroker xUCB = UniversalContentBroker.create( getXComponentContext() ); + XContentIdentifier xId = xUCB.createContentIdentifier(_sTDocUrl); + XContent xContent = xUCB.queryContent(xId); + XCommandProcessor xCmdProcessor = UnoRuntime.queryInterface(XCommandProcessor.class, xContent); + Property aProperty = new Property(); + aProperty.Name = _sPropertyName; // "DocumentModel"; //DocumentModel + Command aCommand = new Command(); + aCommand.Name = "getPropertyValues"; + aCommand.Handle = -1; // not available + aCommand.Argument = new Property[]{aProperty}; + Object oAny = xCmdProcessor.execute(aCommand, 0, null); + XRow xRow = UnoRuntime.queryInterface(XRow.class, oAny); + return xRow; + }catch(Exception exception){ + exception.printStackTrace(System.err); + return null; + }} + + + protected String[] getTDocTitles(String[] _sTDocUrls){ + String[] sTitles = new String[_sTDocUrls.length]; + for (int i = 0; i < _sTDocUrls.length; i++){ + sTitles[i] = getTitleByTDocUrl(_sTDocUrls[i]); + } + return sTitles; + } + + + protected String[] getTDocUrls(){ + try{ + Object oSimpleFileAccess = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.ucb.SimpleFileAccess", getXComponentContext()); + XSimpleFileAccess xSimpleFileAccess = UnoRuntime.queryInterface(XSimpleFileAccess.class, oSimpleFileAccess); + String[] sContent = xSimpleFileAccess.getFolderContents("vnd.sun.star.tdoc:/", false); + return sContent; + } catch( Exception e ) { + System.err.println( e ); + return new String[]{}; + }} + + + public XComponent openEmptyDocument(String _sUrl){ + try{ + PropertyValue[] aPropertyValues = new PropertyValue[1]; + aPropertyValues[0] = new PropertyValue(); + aPropertyValues[0].Name = "Hidden"; + aPropertyValues[0].Value = Boolean.TRUE; + Object oDesktop = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.frame.Desktop", getXComponentContext()); + XComponentLoader xCL = UnoRuntime.queryInterface(XComponentLoader.class, oDesktop); + return xCL.loadComponentFromURL(_sUrl, "_default", 0, aPropertyValues); + } + catch( Exception exception ) { + System.err.println( exception ); + return null; + }} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/TestInspector.java b/odk/examples/java/Inspector/TestInspector.java new file mode 100644 index 000000000..208acf25b --- /dev/null +++ b/odk/examples/java/Inspector/TestInspector.java @@ -0,0 +1,88 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.lang.XSingleComponentFactory; +import com.sun.star.uno.UnoRuntime; + +public class TestInspector { + + public static void main(String args[]) { + com.sun.star.uno.XComponentContext xContext = null; + try { + // get the remote office component context + xContext = com.sun.star.comp.helper.Bootstrap.bootstrap(); + if( xContext != null ) + System.out.println("Connected to a running office ..."); + } + catch( Exception e) { + e.printStackTrace(System.err); + System.exit(1); + } + + try { + com.sun.star.lang.XMultiComponentFactory xMCF = xContext.getServiceManager(); + // Creating an instance of the instance inspector with arguments + + XSingleComponentFactory xFactory = Inspector.__getComponentFactory(Inspector._Inspector.class.getName()); + Object obj= null; + if (xFactory != null) { + obj = xFactory.createInstanceWithContext(xContext); + } + org.openoffice.XInstanceInspector xInstInspector = null; + if (obj != null) { + xInstInspector = UnoRuntime.queryInterface(org.openoffice.XInstanceInspector.class, obj); + } + + /* A desktop environment contains tasks with one or more + frames in which components can be loaded. Desktop is the + environment for components which can instantiate within + frames. */ + com.sun.star.frame.XComponentLoader xCmpLoader = UnoRuntime.queryInterface( com.sun.star.frame.XComponentLoader.class, + xMCF.createInstanceWithContext("com.sun.star.frame.Desktop", xContext)); + + // Load a new spreadsheet document, which will be automatically + // displayed and is used for inspection + com.sun.star.lang.XComponent xComp = xCmpLoader.loadComponentFromURL("private:factory/scalc", "_blank", 0, new com.sun.star.beans.PropertyValue[0] ); + xInstInspector.inspect(xCmpLoader, ""); + System.out.println("You can now inspect the new spreadsheet " + "document ...\n"); + } + catch( Exception e ) { + System.err.println( e + e.getMessage()); + e.printStackTrace(); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/UnoMethodNode.java b/odk/examples/java/Inspector/UnoMethodNode.java new file mode 100644 index 000000000..a620fc81a --- /dev/null +++ b/odk/examples/java/Inspector/UnoMethodNode.java @@ -0,0 +1,228 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.reflection.ParamInfo; +import com.sun.star.reflection.ParamMode; +import com.sun.star.reflection.XIdlClass; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.TypeClass; + +public class UnoMethodNode extends UnoNode{ + private XIdlMethod m_xIdlMethod = null; + private Object[] m_oParamObjects = null; + private Object m_oUnoReturnObject = null; + private boolean m_bisInvoked = false; + private XUnoMethodNode m_xUnoMethodNode = null; + + + /** Creates a new instance of UnoMethodNode */ + public UnoMethodNode(XIdlMethod _xIdlMethod, Object _oUnoObject, XUnoMethodNode _xUnoMethodNode) { + super(_oUnoObject); + m_xIdlMethod = _xIdlMethod; + m_oParamObjects = new Object[m_xIdlMethod.getParameterInfos().length]; + m_xUnoMethodNode = _xUnoMethodNode; + } + + protected boolean isFoldable(){ + return ((!this.isPrimitive()) && (getTypeClass().getValue() != TypeClass.VOID_value)); + } + + protected boolean isInvokable(){ + boolean bisFoldable = true; + XIdlClass[] xIdlClasses = m_xIdlMethod.getParameterTypes(); + for (int i = 0; i < xIdlClasses.length; i++){ + bisFoldable = Introspector.isPrimitive(xIdlClasses[i].getTypeClass()); + if (!bisFoldable){ + return false; + } + } + return bisFoldable; + } + + public XIdlMethod getXIdlMethod(){ + return m_xIdlMethod; + } + + + @Override + public String getAnchor(){ + return getXIdlMethod().getName(); + } + + + public String getName(){ + return getXIdlMethod().getName(); + } + + + public Object invoke(){ + Object oUnoReturnObject = null; + if (!hasParameters()){ + oUnoReturnObject = invokeParameterlessMethod(); + m_bisInvoked = true; + } + else{ + java.util.List<Object> oUnoMethodObjects = m_xUnoMethodNode.getMethodObjects(); + if (oUnoMethodObjects != null){ + for (int i = 0; i < getXIdlMethod().getParameterInfos().length; i++){ + this.m_oParamObjects[i] = oUnoMethodObjects.get(i); + } + if (oUnoMethodObjects.size() == m_oParamObjects.length + 1){ + oUnoReturnObject = oUnoMethodObjects.get(oUnoMethodObjects.size()-1); + } + m_bisInvoked = (oUnoReturnObject != null); + } + } + m_oUnoReturnObject = oUnoReturnObject; + return oUnoReturnObject; + } + + + public boolean isInvoked(){ + return m_bisInvoked; + } + + + protected String getNodeDescription(){ + String sNodeDescription = ""; + String sParameters = getParameterDescription(); + if (m_xIdlMethod.getParameterInfos().length > 0){ + sNodeDescription = getStandardMethodDescription(); + } + else{ + TypeClass typeClass = getTypeClass(); + if (typeClass != TypeClass.VOID){ + sNodeDescription = getStandardMethodDescription(); + } + else{ + sNodeDescription = getStandardMethodDescription(); + } + } + return sNodeDescription; + } + + + public String getStandardMethodDescription(){ + String sNodeDescription = m_xIdlMethod.getReturnType().getName() + " " + m_xIdlMethod.getName() + " (" + getParameterDescription() + " )"; + if (isPrimitive()){ + sNodeDescription += ""; + } + return sNodeDescription; + } + + + public boolean hasParameters(){ + return (m_xIdlMethod.getParameterInfos().length > 0); + } + + + public Object[] getLastParameterObjects(){ + return m_oParamObjects; + } + + + public Object getLastUnoReturnObject(){ + return m_oUnoReturnObject; + } + + + public String getParameterDescription(){ + ParamInfo[] paramInfo = m_xIdlMethod.getParameterInfos(); + String sParameters = ""; + if (Introspector.isValid(paramInfo)) { + // get all parameters with type and mode + for ( int i = 0; i < paramInfo.length; i++ ) { + XIdlClass xIdlClass = paramInfo[ i ].aType; + if ( i == 0 ) { + // the first parameter has no leading comma + sParameters += "[" + getParamMode(paramInfo[ i ].aMode ) + "] " + xIdlClass.getName(); + } + else { + // all other parameters are separated with comma + sParameters += ", [" + getParamMode(paramInfo[ i ].aMode ) + "] " + xIdlClass.getName(); + } + } + } + return sParameters; + } + + + // return the parameter mode (IN, OUT, INOUT) + private static String getParamMode(ParamMode paramMode) { + String toReturn = ""; + if ( paramMode == ParamMode.IN ) { + toReturn = "IN"; + } + if ( paramMode == ParamMode.OUT ) { + toReturn = "OUT"; + } + if ( paramMode == ParamMode.INOUT ) { + toReturn = "INOUT"; + } + return toReturn; + } + + public TypeClass getTypeClass(){ + XIdlClass xIdlClass = m_xIdlMethod.getReturnType(); + return xIdlClass.getTypeClass(); + } + + + private Object invokeParameterlessMethod(){ + try { + Object[][] aParamInfo = new Object[1][]; + aParamInfo[0] = new Object[] {}; + return getXIdlMethod().invoke(getUnoObject(), aParamInfo); + } catch (Exception ex) { + ex.printStackTrace(System.err); + return null; + }} + + + public boolean isPrimitive(){ + return Introspector.isObjectPrimitive(m_xIdlMethod.getClass(), getTypeClass()); + } + + + protected Object invoke(Object _oUnoObject, Object[] oParameters) throws com.sun.star.uno.Exception{ + Object[][] aParams = new Object[1][oParameters.length]; + for ( int i = 0; i < oParameters.length; i++ ) { + aParams[0][i] = oParameters[i]; + } + return m_xIdlMethod.invoke(_oUnoObject, aParams); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/UnoNode.java b/odk/examples/java/Inspector/UnoNode.java new file mode 100644 index 000000000..0e72d1efd --- /dev/null +++ b/odk/examples/java/Inspector/UnoNode.java @@ -0,0 +1,351 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.beans.PropertyValue; +import com.sun.star.frame.FrameSearchFlag; +import com.sun.star.frame.XDesktop; +import com.sun.star.frame.XDispatch; +import com.sun.star.frame.XDispatchProvider; +import com.sun.star.frame.XFrame; +import com.sun.star.lang.XMultiComponentFactory; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.uno.AnyConverter; +import com.sun.star.uno.Type; +import com.sun.star.uno.TypeClass; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; +import com.sun.star.util.URL; +import com.sun.star.util.XURLTransformer; + +public class UnoNode{ + + + Object m_oUnoObject; + private XMultiComponentFactory m_xMultiComponentFactory; + private XComponentContext m_xComponentContext; + private Object[] m_oParamObjects = null; + private int m_nNodeType = XUnoNode.nOTHERS; + private Type aType = null; + private String sLabel = ""; + + + + /** Creates a new instance of UnoNode */ + public UnoNode(Object _oUnoObject) { + m_xComponentContext = Introspector.getIntrospector().getXComponentContext(); + m_xMultiComponentFactory = m_xComponentContext.getServiceManager(); + m_oUnoObject = _oUnoObject; + } + + public UnoNode(Object _oUnoObject, Type _aType) { + this(_oUnoObject); + aType = _aType; + m_nNodeType = XUnoNode.nINTERFACE; + } + + public Object getUnoObject(){ + return m_oUnoObject; + } + + + private XComponentContext getXComponentContext(){ + return m_xComponentContext; + } + + + private XMultiComponentFactory getXMultiComponentFactory(){ + return m_xMultiComponentFactory; + } + + + public String getAnchor(){ + return ""; + } + + public int getNodeType(){ + return m_nNodeType; + } + + public void setNodeType(int _nNodeType){ + m_nNodeType = _nNodeType; + } + + public String getClassName(){ + String sClassName = ""; + if (m_nNodeType == XUnoNode.nINTERFACE){ + sClassName = aType.getTypeName(); + } + else if(m_nNodeType == XUnoNode.nSERVICE){ + sClassName = sLabel; + } + return sClassName; + } + + + public Type getUnoType(){ + return aType; + } + + protected void setLabel(String _sLabel){ + sLabel = _sLabel; + } + + public void openIdlDescription(String _sIDLUrl, String _sClassName){ + try{ + String sIDLUrl = _sIDLUrl; + String sAnchor = ""; // TODO find out how the Anchor may be set at the html file; //_sAnchor; + boolean bExists = Introspector.getIntrospector().getXSimpleFileAccess().exists(sIDLUrl); + if (sIDLUrl.equals("") || (!bExists)){ + sIDLUrl = "https://api.libreoffice.org/" + Inspector.sIDLDOCUMENTSUBFOLDER; + } + if (!sIDLUrl.endsWith("/")){ + sIDLUrl += "/"; + } + if (_sClassName.equals("")){ + sIDLUrl += "index"; + sAnchor = ""; + } + else{ + sIDLUrl += _sClassName.replace(".", "_1_1"); + } + sIDLUrl += ".html"; + if (sAnchor != null){ + if (!sAnchor.equals("")){ + sIDLUrl += "#" + sAnchor; + } + } + URL openHyperlink = getDispatchURL(".uno:OpenHyperlink"); + PropertyValue pv = new PropertyValue(); + pv.Name = "URL"; + pv.Value = sIDLUrl; + getXDispatcher(openHyperlink).dispatch(openHyperlink, new PropertyValue[] {pv}); + } catch(Exception exception) { + exception.printStackTrace(System.err); + }} + + + private com.sun.star.util.URL getDispatchURL(String _sURL){ + try { + Object oTransformer = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.util.URLTransformer", getXComponentContext()); + XURLTransformer xTransformer = UnoRuntime.queryInterface(XURLTransformer.class, oTransformer); + com.sun.star.util.URL[] oURL = new com.sun.star.util.URL[1]; + oURL[0] = new com.sun.star.util.URL(); + oURL[0].Complete = _sURL; + xTransformer.parseStrict(oURL); + return oURL[0]; + } catch (Exception e) { + e.printStackTrace(System.err); + } + return null; + } + + + private XFrame getCurrentFrame(){ + try{ + Object oDesktop = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.frame.Desktop", getXComponentContext()); + XDesktop xDesktop = UnoRuntime.queryInterface(XDesktop.class, oDesktop); + return xDesktop.getCurrentFrame(); + } catch (Exception e) { + e.printStackTrace(System.err); + return null; + }} + + + private XDispatch getXDispatcher(com.sun.star.util.URL oURL) { + try { + com.sun.star.util.URL[] oURLArray = new com.sun.star.util.URL[1]; + oURLArray[0] = oURL; + XDispatchProvider xDispatchProvider = UnoRuntime.queryInterface(XDispatchProvider.class, getCurrentFrame()); + XDispatch xDispatch = xDispatchProvider.queryDispatch(oURLArray[0], "_top", FrameSearchFlag.ALL); // "_self" + return xDispatch; + } catch (Exception e) { + e.printStackTrace(System.err); + return null; + }} + + + public boolean isFilterApplicable(String _sFilter, String _sName){ + boolean bFilterDoesApply = true; + if (_sFilter.length() > 0){ + if (_sName.indexOf(_sFilter) == -1){ + bFilterDoesApply = false; + } + } + return bFilterDoesApply; + } + + + public static String getDisplayValueOfPrimitiveType(Object _objectElement){ + String sValue =""; + try{ + if (AnyConverter.isString(_objectElement)){ + sValue = AnyConverter.toString(_objectElement); + } + else if (AnyConverter.isBoolean(_objectElement)){ + sValue += AnyConverter.toBoolean(_objectElement); + } + else if (AnyConverter.isByte(_objectElement)){ + sValue += AnyConverter.toByte(_objectElement); + } + else if (AnyConverter.isChar(_objectElement)){ + sValue += AnyConverter.toChar(_objectElement); + } + else if (AnyConverter.isDouble(_objectElement)){ + sValue += AnyConverter.toDouble(_objectElement); + } + else if (AnyConverter.isFloat(_objectElement)){ + sValue += AnyConverter.toFloat(_objectElement); + } + else if (AnyConverter.isInt(_objectElement)){ + sValue += AnyConverter.toInt(_objectElement); + } + else if (AnyConverter.isLong(_objectElement)){ + sValue += AnyConverter.toLong(_objectElement); + } + else if (AnyConverter.isShort(_objectElement)){ + sValue += AnyConverter.toShort(_objectElement); + } + } + catch( Exception e ) { + System.err.println( e ); + } + return sValue; + } + + protected static String[] getDisplayValuesofPrimitiveArray(Object _oUnoObject){ + String[] sDisplayValues = null; + try{ + Type aType = AnyConverter.getType(_oUnoObject); + TypeClass aTypeClass = aType.getTypeClass(); + int nTypeValue = aTypeClass.getValue(); + if (nTypeValue == TypeClass.SEQUENCE_value){ + nTypeValue = (sequenceComponentType(aType)).getTypeClass().getValue(); + } + switch (nTypeValue){ + case TypeClass.BOOLEAN_value: + boolean[] bBooleans = (boolean[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[bBooleans.length]; + for (int i = 0; i < bBooleans.length; i++){ + sDisplayValues[i] = Boolean.toString(bBooleans[i]); + } + break; + case TypeClass.BYTE_value: + byte[] bBytes = (byte[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[bBytes.length]; + for (int i = 0; i < bBytes.length; i++){ + sDisplayValues[i] = "" + bBytes[i]; + } + break; + case TypeClass.DOUBLE_value: + double[] fdoubles = (double[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[fdoubles.length]; + for (int i = 0; i < fdoubles.length; i++){ + sDisplayValues[i] = String.valueOf(fdoubles[i]); + } + break; + case TypeClass.FLOAT_value: + float[] ffloats = (float[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[ffloats.length]; + for (int i = 0; i < ffloats.length; i++){ + sDisplayValues[i] = String.valueOf(ffloats[i]); + } + break; + case TypeClass.LONG_value: + int[] nints = (int[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[nints.length]; + for (int i = 0; i < nints.length; i++){ + sDisplayValues[i] = String.valueOf(nints[i]); + } + break; + case TypeClass.HYPER_value: + long[] nlongs = (long[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[nlongs.length]; + for (int i = 0; i < nlongs.length; i++){ + sDisplayValues[i] = String.valueOf(nlongs[i]); + } + break; + case TypeClass.SHORT_value: + short[] nShorts = (short[]) AnyConverter.toArray(_oUnoObject); + sDisplayValues = new String[nShorts.length]; + for (int i = 0; i < nShorts.length; i++){ + sDisplayValues[i] = "" + nShorts[i]; + } + break; + case TypeClass.CHAR_value: + break; + default: + System.out.println("Value could not be retrieved: " + aType.getTypeClass().getClass().getName()); + } + return sDisplayValues; + } + catch( Exception e ) { + System.err.println( e ); + return null; + }} + + + private static Type sequenceComponentType(Type sequenceType) { + String n = sequenceType.getTypeName(); + final String PREFIX = "[]"; + return new Type(n.substring(PREFIX.length())); + } + + + + + + public static String getNodeDescription(Object _oUnoObject){ + XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _oUnoObject ); + if ( xServiceInfo != null ) { + return xServiceInfo.getImplementationName(); + } + if (Introspector.isObjectPrimitive(_oUnoObject)){ //super.isO{sObjectClassName.equals("String"))issClassName.equals("String")) + return _oUnoObject.toString(); + } + else{ + return _oUnoObject.getClass().getName(); + } + } + + public void setParameterObjects(Object[] _oParamObjects){ + m_oParamObjects = _oParamObjects; + } + + public Object[] getParameterObjects(){ + return m_oParamObjects; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/UnoPropertyNode.java b/odk/examples/java/Inspector/UnoPropertyNode.java new file mode 100644 index 000000000..51b6569b2 --- /dev/null +++ b/odk/examples/java/Inspector/UnoPropertyNode.java @@ -0,0 +1,218 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.beans.Property; +import com.sun.star.beans.PropertyValue; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.reflection.XPropertyTypeDescription; +import com.sun.star.uno.UnoRuntime; + +public class UnoPropertyNode extends UnoNode{ + + private Property aProperty; + private PropertyValue aPropertyValue; + private String m_sPropertyName; + private Object m_oUnoReturnObject; + private int m_nPropertyType = XUnoPropertyNode.nDEFAULT; + private String sLabel = ""; + + + /** Creates a new instance of UnoMethodNode */ + public UnoPropertyNode(Property _aProperty, Object _oUnoObject, Object _oUnoReturnObject) { + super(_oUnoObject); + aProperty = _aProperty; + m_sPropertyName = aProperty.Name; + m_oUnoReturnObject = _oUnoReturnObject; + } + + + public UnoPropertyNode(Property _aProperty){ + super(null); + aProperty = _aProperty; + m_sPropertyName = aProperty.Name; + m_oUnoReturnObject = null; + } + + public UnoPropertyNode(PropertyValue _aPropertyValue, Object _oUnoObject, Object _oUnoReturnObject) { + super(_oUnoObject); + m_oUnoReturnObject = _oUnoReturnObject; + aPropertyValue = _aPropertyValue; + m_sPropertyName = aPropertyValue.Name; + } + + + public int getPropertyNodeType(){ + return m_nPropertyType; + } + + + public void setPropertyNodeType(int _nPropertyType){ + m_nPropertyType = _nPropertyType; + } + + + public String getPropertyName(){ + return m_sPropertyName; + } + + public String getName(){ + return this.m_sPropertyName; + } + + + @Override + public String getClassName(){ + String sClassName = ""; + if (m_oUnoObject != null){ + XServiceInfo xServiceInfo = UnoRuntime.queryInterface(XServiceInfo.class, m_oUnoObject); + if (xServiceInfo != null){ + String[] sServiceNames = xServiceInfo.getSupportedServiceNames(); + for (int i = 0; i < sServiceNames.length; i++){ + if (doesServiceSupportProperty(sServiceNames[i], m_sPropertyName)){ + sClassName = sServiceNames[i]; + break; + } + } + } + } + else{ + sClassName = "com.sun.star.beans.Property"; + } + return sClassName; + } + + + @Override + public String getAnchor(){ + return m_sPropertyName; + } + + + + private boolean doesServiceSupportProperty(String _sServiceName, String _sPropertyName){ + try { + XPropertyTypeDescription[] xPropertyTypeDescriptions = Introspector.getIntrospector().getPropertyDescriptionsOfService(_sServiceName); + for (int i = 0; i < xPropertyTypeDescriptions.length; i++){ + if (xPropertyTypeDescriptions[i].getName().equals(_sServiceName + "." + _sPropertyName)){ + return true; + } + } + } catch ( java.lang.Exception e) { + System.out.println(System.out); + } + return false; + } + + + public Object getUnoReturnObject(){ + return m_oUnoReturnObject; + } + + + private boolean isPrimitive(){ + boolean bIsPrimitive = true; + if (getUnoReturnObject() != null){ + if (getProperty() != null){ + bIsPrimitive = Introspector.isObjectPrimitive(getUnoReturnObject().getClass(), getProperty().Type.getTypeClass()); + } + else{ + bIsPrimitive = Introspector.isObjectPrimitive(getUnoReturnObject().getClass()); + } + } + else{ + bIsPrimitive = Introspector.isObjectPrimitive(aProperty.Type.getTypeClass()); + } + return bIsPrimitive; + } + + + protected boolean isFoldable(){ + boolean bIsFoldable = false; + if (! isPrimitive()){ + String sTypeName = getUnoReturnObject().getClass().getName(); + bIsFoldable = (!sTypeName.equals("com.sun.star.uno.Type")); + } + return bIsFoldable; + } + + + protected String getLabel(){ + if (!sLabel.equals("")){ + if (! isPrimitive()){ + if (isFoldable()){ + sLabel = getPropertyTypeDescription(aProperty, getUnoReturnObject()); + } + else{ + sLabel = getStandardPropertyDescription(aProperty, getUnoReturnObject()); + } + } + else { + sLabel = getStandardPropertyDescription(aProperty, getUnoReturnObject()); + } + } + return sLabel; + } + + public Property getProperty(){ + return aProperty; + } + + private static String getPropertyTypeDescription(Property _aProperty, Object _oUnoObject){ + return _aProperty.Type.getTypeName() + " " + _aProperty.Name + " = " + _oUnoObject.toString(); + } + + + protected static String getStandardPropertyDescription(Property _aProperty, Object _objectElement){ + if (!Introspector.isObjectPrimitive(_objectElement)){ + return _aProperty.Name + " = (" + _aProperty.Type.getTypeName() + ") "; + } + else{ + return _aProperty.Name + " (" + _aProperty.Type.getTypeName() + ") = " + getDisplayValueOfPrimitiveType(_objectElement); + } + } + + + protected static String getStandardPropertyValueDescription(PropertyValue _aPropertyValue){ + if (!Introspector.isObjectPrimitive(_aPropertyValue.Value)){ + return _aPropertyValue.Name; + } + else{ + return _aPropertyValue.Name + " : " + UnoNode.getDisplayValueOfPrimitiveType(_aPropertyValue.Value); + } + } +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/UnoTreeRenderer.java b/odk/examples/java/Inspector/UnoTreeRenderer.java new file mode 100644 index 000000000..81e62a6d1 --- /dev/null +++ b/odk/examples/java/Inspector/UnoTreeRenderer.java @@ -0,0 +1,122 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import java.awt.Component; +import java.awt.Graphics; +import javax.swing.Icon; +import javax.swing.ImageIcon; +import javax.swing.JTree; +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.DefaultTreeCellRenderer; + + + +public class UnoTreeRenderer extends DefaultTreeCellRenderer{ + private Icon m_oMethodIcon; + private Icon m_oPropertyIcon; + private Icon m_oContainerIcon; + private Icon m_oContentIcon; + private Icon m_oServiceIcon; + private Icon m_oInterfaceIcon; + private Icon m_oPropertyValueIcon; + private boolean bSelected; + private int nWidth = 0; + + + /** Creates a new instance of UnoTreeRenderer */ + public UnoTreeRenderer(){ + super(); + try { + + final ClassLoader loader = ClassLoader.getSystemClassLoader(); + m_oMethodIcon = new ImageIcon(loader.getResource("images/methods_16.png")); + m_oPropertyIcon = new ImageIcon("images/properties_16.png"); + m_oPropertyValueIcon = new ImageIcon("images/properties_16.png"); + m_oContainerIcon = new ImageIcon("images/containers_16.png"); + m_oServiceIcon = new ImageIcon("images/services_16.png"); + m_oInterfaceIcon = new ImageIcon("images/interfaces_16.png"); + m_oContentIcon = new ImageIcon("images/content_16.png"); + } catch (RuntimeException e) { + System.out.println("Sorry, could not locate resources, treecell icons will not be displayed."); + } + } + + + @Override + public synchronized Component getTreeCellRendererComponent(JTree tree,Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus){ + try{ + bSelected = sel; + DefaultMutableTreeNode node = (DefaultMutableTreeNode) value; + Component rc = super.getTreeCellRendererComponent( tree, value, sel,expanded, leaf, row,hasFocus); + String sLabelText = (String)node.getUserObject(); + if (sLabelText != null){ + if (sLabelText.equals(XUnoFacetteNode.SCONTAINERDESCRIPTION)){ + } else if (sLabelText.equals(XUnoFacetteNode.SCONTENTDESCRIPTION)){ + } else if (sLabelText.equals(XUnoFacetteNode.SINTERFACEDESCRIPTION)){ + } else if (sLabelText.equals(XUnoFacetteNode.SMETHODDESCRIPTION)){ + } else if (sLabelText.equals(XUnoFacetteNode.SPROPERTYDESCRIPTION)){ + } else if (sLabelText.startsWith(XUnoFacetteNode.SPROPERTYINFODESCRIPTION)){ + } else if (sLabelText.equals(XUnoFacetteNode.SPROPERTYVALUEDESCRIPTION)){ + } else if (sLabelText.equals(XUnoFacetteNode.SSERVICEDESCRIPTION)){ + } else{ + setText(sLabelText); + rc.validate(); + } + setSize(getPreferredSize()); + rc.validate(); + doLayout(); + } + } catch (RuntimeException e) { + System.out.println("Sorry, icon for treecell could not be displayed."); + } + return this; + } + + + + @Override + public void paintComponent(Graphics g) { + int x; + if(getIcon() == null) { + x = 0; + } else { + x = getIcon().getIconWidth() + getIconTextGap(); + } + g.setColor(getForeground()); + super.paintComponent(g); + } +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XDialogProvider.java b/odk/examples/java/Inspector/XDialogProvider.java new file mode 100644 index 000000000..78b0c792e --- /dev/null +++ b/odk/examples/java/Inspector/XDialogProvider.java @@ -0,0 +1,68 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +public interface XDialogProvider { + + public static String SINVOKE = "Invoke"; + + public static String SADDTOSOURCECODE = "Add to Sourcecode"; + + public void enablePopupMenuItem(String _sMenuTitle, boolean _bdoEnable); + + public void showPopUpMenu(Object invoker, int x, int y) throws java.lang.ClassCastException; + + public InspectorPane getSelectedInspectorPage(); + + public void addInspectorPage(String _sTitle, Object _oContainer); + + public InspectorPane getInspectorPage(int _nIndex); + + public int getInspectorPageCount(); + + public void selectInspectorPageByIndex(int nTabIndex); + + public void show(int _nPageIndex) throws java.lang.ClassCastException; + + public void selectSourceCodeLanguage(int _nLanguage); + + + + // returns one of the constants defined in XLanguageSourceCodeGenerator + public int getLanguage(); + + public String getIDLPath(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XInstanceInspector.idl b/odk/examples/java/Inspector/XInstanceInspector.idl new file mode 100644 index 000000000..ca96a27e1 --- /dev/null +++ b/odk/examples/java/Inspector/XInstanceInspector.idl @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +#ifndef INCLUDED_ORG_OPENOFFICE_XINSTANCEINSPECTOR_IDL +#define INCLUDED_ORG_OPENOFFICE_XINSTANCEINSPECTOR_IDL + +#include <com/sun/star/uno/XInterface.idl> + +module org { module openoffice { + + interface XInstanceInspector { + /** + * For a given instance this method displays all services, interfaces, + * methods, attributes, and contents in a tree. All dependent + * instances are also inspected and displayed, so the user could browse + * the tree. If you press the key "F1", the API-documentation from + * www.openoffice.org for the current instance will be displayed in a + * new window. + */ + void inspect( [in] any aInstance, [in] string sTitle ); + }; + +}; }; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XLanguageSourceCodeGenerator.java b/odk/examples/java/Inspector/XLanguageSourceCodeGenerator.java new file mode 100644 index 000000000..8729471e2 --- /dev/null +++ b/odk/examples/java/Inspector/XLanguageSourceCodeGenerator.java @@ -0,0 +1,108 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import com.sun.star.uno.TypeClass; + +public interface XLanguageSourceCodeGenerator { + + public static final int nJAVA = 0; + public static final int nCPLUSPLUS = 1; + public static final int nBASIC = 2; + + public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass); + + public String getFinalHeaderStatements(); + + public void assignqueryInterfaceHeaderSourceCode(); + + public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription); + + public String getMethodTerminationSourceCode(); + + public String getStatementTerminationCharacter(); + + public boolean needsqueryInterface(); + + public String getqueryInterfaceSourceCode(String _sReturnValueDescription, String _sClassName, String _sObjectDescription); + + public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName); + + public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember); + + public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader); + + public String getbooleanTypeDescription(); + + public String getbyteTypeDescription(); + + public String getshortTypeDescription(); + + + + public String getlongTypeDescription(); + + public String getunsignedlongTypeDescription(); + + public String gethyperTypeDescription(); + + public String getunsignedhyperTypeDescription(); + + public String getfloatTypeDescription(); + + public String getdoubleTypeDescription(); + + public String getcharTypeDescription(); + + public String getstringTypeDescription(boolean _bAsHeaderSourceCode); + + + + public String getanyTypeDescription(boolean _bAsHeaderSourceCode); + + + + public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean _bIsArray, TypeClass aTypeClass, boolean _bInitialize); + + public String getMethodSeparator(); + + public String getStringValue(String _sValue); + + public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName); + + public String castLiteral(String _sExpression, TypeClass _aTypeClass); + + public String getCommentSign(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XTreeControlProvider.java b/odk/examples/java/Inspector/XTreeControlProvider.java new file mode 100644 index 000000000..1cb69c972 --- /dev/null +++ b/odk/examples/java/Inspector/XTreeControlProvider.java @@ -0,0 +1,96 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.beans.Property; +import com.sun.star.beans.PropertyValue; +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.Type; + +public interface XTreeControlProvider { + + + + public String enableFilterElements(XUnoNode _oUnoNode); + + public void setSourceCode(String _sSourceCode); + + public Object inspect(java.lang.Object _oUserDefinedObject, String _sTitle) throws com.sun.star.uno.RuntimeException; + + public void nodeInserted(XUnoNode _oParentNode, XUnoNode _oChildNode, int index); + + public void nodeChanged(XUnoNode _oNode); + + public boolean setNodeVisible(Object node, boolean v); + + public XUnoNode getSelectedNode(); + + public XTreePathProvider getSelectedPath(); + + public void expandPath(XTreePathProvider xTreePathProvider) throws java.lang.ClassCastException; + + public void addTreeExpandListener(); + + public void addInspectorPane(InspectorPane _oInspectorPane); + + public boolean isPropertyNode(XUnoNode _oUnoNode); + + public boolean isMethodNode(XUnoNode _oUnoNode); + + public boolean isFacetteNode(XUnoNode _oUnoNode); + + public XUnoNode addUnoNode(Object _oUnoObject); + + public XUnoNode addUnoNode(Object _oUnoObject, Type _aType); + + public XUnoFacetteNode addUnoFacetteNode(XUnoNode _oParentNode, String _sNodeDescription, Object _oUnoObject); + + public XUnoMethodNode addMethodNode(Object _objectElement, XIdlMethod _xIdlMethod); + + public XUnoPropertyNode addUnoPropertyNodeWithName(Property _aProperty); + + public XUnoPropertyNode addUnoPropertyNodeWithHandle(Property _aProperty); + + public XUnoPropertyNode addUnoPropertyNodeWithType(Property _aProperty); + + public XUnoPropertyNode addUnoPropertyNodeWithAttributesDescription(Property _aProperty); + + public XUnoPropertyNode addUnoPropertyNode(Object _oUnoObject, Property _aProperty); + + public XUnoPropertyNode addUnoPropertyNode(Object _oUnoObject, PropertyValue _aPropertyValue, Object _oReturnObject); + + public XUnoPropertyNode addUnoPropertyNode(Object _oUnoObject, Property _aProperty, Object _oUnoReturnObject); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XTreePathProvider.java b/odk/examples/java/Inspector/XTreePathProvider.java new file mode 100644 index 000000000..ecbf52dd4 --- /dev/null +++ b/odk/examples/java/Inspector/XTreePathProvider.java @@ -0,0 +1,33 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +public interface XTreePathProvider { + + public XUnoNode getLastPathComponent(); + + public XUnoNode getPathComponent(int i); + + public int getPathCount(); + + public XTreePathProvider getParentPath(); + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XUnoFacetteNode.java b/odk/examples/java/Inspector/XUnoFacetteNode.java new file mode 100644 index 000000000..ad1e114c1 --- /dev/null +++ b/odk/examples/java/Inspector/XUnoFacetteNode.java @@ -0,0 +1,66 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + + + +public interface XUnoFacetteNode extends XUnoNode { + + public static String SMETHODDESCRIPTION = "Methods"; + public static String SPROPERTYDESCRIPTION = "Properties"; + public static String SPROPERTYINFODESCRIPTION = "PropertyInfo"; + public static String SCONTAINERDESCRIPTION = "Container"; + public static String SSERVICEDESCRIPTION = "Services"; + public static String SINTERFACEDESCRIPTION = "Interfaces"; + public static String SCONTENTDESCRIPTION = "Content"; + public static String SPROPERTYVALUEDESCRIPTION = "PropertyValues"; + + + public boolean isMethodNode(); + + public boolean isPropertyNode(); + + public boolean isContainerNode(); + + public boolean isServiceNode(); + + public boolean isInterfaceNode(); + + public String getFilter(); + + public void setFilter(String _sFilter); + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XUnoMethodNode.java b/odk/examples/java/Inspector/XUnoMethodNode.java new file mode 100644 index 000000000..4749c92a0 --- /dev/null +++ b/odk/examples/java/Inspector/XUnoMethodNode.java @@ -0,0 +1,70 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + +import com.sun.star.reflection.XIdlMethod; +import com.sun.star.uno.TypeClass; + + +public interface XUnoMethodNode extends XUnoNode { + + public XIdlMethod getXIdlMethod(); + + public boolean isInvoked(); + + public Object invoke() throws com.sun.star.uno.Exception; + + public Object invoke(Object _oUnoObject, Object[] _oParameters) throws com.sun.star.uno.Exception; + + public boolean isInvokable(); + + public boolean hasParameters(); + + public Object[] getLastParameterObjects(); + + public Object getLastUnoReturnObject(); + + public TypeClass getTypeClass(); + + public boolean isPrimitive(); + + public java.util.List<Object> getMethodObjects(); + + public boolean isFoldable(); + + public String getStandardMethodDescription(); + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XUnoNode.java b/odk/examples/java/Inspector/XUnoNode.java new file mode 100644 index 000000000..11eba35da --- /dev/null +++ b/odk/examples/java/Inspector/XUnoNode.java @@ -0,0 +1,87 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +import com.sun.star.uno.Type; +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ + + +public interface XUnoNode { + + public static final int nINTERFACE = 1; + public static final int nSERVICE = 2; + public static final int nOTHERS = 3; + + public String getAnchor(); + + public String getClassName(); + + public void openIdlDescription(String _sIDLUrl); + + public boolean isFilterApplicable(String _sFilter); + + public void setVisible(String _sFilter); + + public void setParameterObjects(Object[] _oParamObjects); + + public Object[] getParameterObjects(); + + public String getName(); + + public void setFoldable(boolean _bIsFoldable); + + public Object getUnoObject(); + + public XUnoNode getParentNode(); + + public void addChildNode(XUnoNode _xUnoNode); + + public void setLabel(String _sLabel); + + public String getLabel(); + + public int getChildCount(); + + public XUnoNode getChild(int _index); + + public int getNodeType(); + + // possible values are nINTERFACE, nSERVICE, nOTHERS + public void setNodeType(int _nNodeType); + + /** delivers only the Uno-Type when the NodeType is set to nINTERFACE + * otherwise (when the NodeType has not been set returns null + */ + public Type getUnoType(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/XUnoPropertyNode.java b/odk/examples/java/Inspector/XUnoPropertyNode.java new file mode 100644 index 000000000..1902a5db2 --- /dev/null +++ b/odk/examples/java/Inspector/XUnoPropertyNode.java @@ -0,0 +1,54 @@ +/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * the BSD license. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Sun Microsystems, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + *************************************************************************/ +import com.sun.star.beans.Property; + + +public interface XUnoPropertyNode extends XUnoNode { + + public static int nDEFAULT = 0; + public static int nPROPERTYSETINFOTYPE = 1; + + + public Object getUnoReturnObject(); + + public int getPropertyNodeType(); + + public void setPropertyNodeType(int _nPropertyType); + + public Property getProperty(); + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/odk/examples/java/Inspector/images/containers_16.png b/odk/examples/java/Inspector/images/containers_16.png Binary files differnew file mode 100644 index 000000000..0b4c62f11 --- /dev/null +++ b/odk/examples/java/Inspector/images/containers_16.png diff --git a/odk/examples/java/Inspector/images/content_16.png b/odk/examples/java/Inspector/images/content_16.png Binary files differnew file mode 100644 index 000000000..758169260 --- /dev/null +++ b/odk/examples/java/Inspector/images/content_16.png diff --git a/odk/examples/java/Inspector/images/interfaces_16.png b/odk/examples/java/Inspector/images/interfaces_16.png Binary files differnew file mode 100644 index 000000000..cf633ac9c --- /dev/null +++ b/odk/examples/java/Inspector/images/interfaces_16.png diff --git a/odk/examples/java/Inspector/images/methods_16.png b/odk/examples/java/Inspector/images/methods_16.png Binary files differnew file mode 100644 index 000000000..25cd8b45c --- /dev/null +++ b/odk/examples/java/Inspector/images/methods_16.png diff --git a/odk/examples/java/Inspector/images/properties_16.png b/odk/examples/java/Inspector/images/properties_16.png Binary files differnew file mode 100644 index 000000000..4e22dd1d5 --- /dev/null +++ b/odk/examples/java/Inspector/images/properties_16.png diff --git a/odk/examples/java/Inspector/images/services_16.png b/odk/examples/java/Inspector/images/services_16.png Binary files differnew file mode 100644 index 000000000..024a16ed6 --- /dev/null +++ b/odk/examples/java/Inspector/images/services_16.png diff --git a/odk/examples/java/Inspector/manifest.mf b/odk/examples/java/Inspector/manifest.mf new file mode 100644 index 000000000..328e8e5bc --- /dev/null +++ b/odk/examples/java/Inspector/manifest.mf @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +X-COMMENT: Main-Class will be added automatically by build + |
