diff options
Diffstat (limited to 'odk/examples/java/Inspector/UnoNode.java')
-rw-r--r-- | odk/examples/java/Inspector/UnoNode.java | 437 |
1 files changed, 437 insertions, 0 deletions
diff --git a/odk/examples/java/Inspector/UnoNode.java b/odk/examples/java/Inspector/UnoNode.java new file mode 100644 index 000000000000..2bfaaf34a356 --- /dev/null +++ b/odk/examples/java/Inspector/UnoNode.java @@ -0,0 +1,437 @@ +/************************************************************************* + * + * 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.reflection.TypeDescriptionSearchDepth; +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.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; +import java.util.List; +import java.util.Vector; + +public class UnoNode{ + + String sPath = null; + 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; + } + + + protected XComponentContext getXComponentContext(){ + return m_xComponentContext; + } + + + protected XMultiComponentFactory getXMultiComponentFactory(){ + return m_xMultiComponentFactory; + } + + + private static XTypeDescriptionEnumerationAccess getXTypeDescriptionEnumerationAccess(){ + return Introspector.getIntrospector().getXTypeDescriptionEnumerationAccess(); + } + + + 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, String _sAnchor){ + 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 = "http://api.openoffice.org/" + Inspector.sIDLDOCUMENTSUBFOLDER; + } + if (!sIDLUrl.endsWith("/")){ + sIDLUrl += "/"; + } + if (_sClassName.equals("")){ + sIDLUrl += "com/sun/star/module-ix"; + sAnchor = ""; + } + else{ + sIDLUrl += _sClassName.replace('.', '/'); + } + if (sAnchor != null){ + if (!sAnchor.equals("")){ + sIDLUrl += "#" + sAnchor; + } + } + sIDLUrl += ".html"; + 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.out); + }} + + + private com.sun.star.util.URL getDispatchURL(String _sURL){ + try { + Object oTransformer = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.util.URLTransformer", getXComponentContext()); + XURLTransformer xTransformer = (XURLTransformer) 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.out); + } + return null; + } + + + private XFrame getCurrentFrame(){ + try{ + Object oDesktop = getXMultiComponentFactory().createInstanceWithContext("com.sun.star.frame.Desktop", getXComponentContext()); + XDesktop xDesktop = (XDesktop) UnoRuntime.queryInterface(XDesktop.class, oDesktop); + return xDesktop.getCurrentFrame(); + } catch (Exception e) { + e.printStackTrace(System.out); + 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 = (XDispatchProvider) UnoRuntime.queryInterface(XDispatchProvider.class, getCurrentFrame()); + XDispatch xDispatch = xDispatchProvider.queryDispatch(oURLArray[0], "_top", FrameSearchFlag.ALL); // "_self" + return xDispatch; + } catch (Exception e) { + e.printStackTrace(System.out); + return null; + }} + + + private PropertyValue[] loadArgs(String url) { + PropertyValue pv = new PropertyValue(); + pv.Name = "URL"; + pv.Value = url; + return new PropertyValue[] {pv}; + } + + + + 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 getServiceDescription(Object _oUnoObject){ +// String sClassName = ""; +// XServiceInfo xServiceInfo = (XServiceInfo) UnoRuntime.queryInterface(XServiceInfo.class, _oUnoObject); +// if (xServiceInfo != null){ +// String[] sChildServiceNames = removeMandatoryServiceNames(xServiceInfo.getSupportedServiceNames()); +// if (sChildServiceNames.length > 0){ +// sClassName = sChildServiceNames[0]; +// } +// } +// return sClassName; +// } + + + + private static String[] getMandatoryServiceNames(String _sServiceName){ + String[] sMandatoryServiceNames = new String[]{}; + try { + TypeClass[] eTypeClasses = new com.sun.star.uno.TypeClass[1]; + eTypeClasses[0] = com.sun.star.uno.TypeClass.SERVICE; + XTypeDescriptionEnumeration xTDEnumeration = getXTypeDescriptionEnumerationAccess().createTypeDescriptionEnumeration(Introspector.getModuleName(_sServiceName), eTypeClasses, TypeDescriptionSearchDepth.INFINITE); + while (xTDEnumeration.hasMoreElements()) { + XTypeDescription xTD = xTDEnumeration.nextTypeDescription(); + if (xTD.getName().equals(_sServiceName)){ + XServiceTypeDescription xServiceTypeDescription = (XServiceTypeDescription) UnoRuntime.queryInterface(XServiceTypeDescription.class, xTD); + XServiceTypeDescription[] xMandatoryServiceTypeDescriptions = xServiceTypeDescription.getMandatoryServices(); + int nlength = xMandatoryServiceTypeDescriptions.length; + sMandatoryServiceNames = new String[nlength]; + for (int i = 0; i < nlength; i++){ + sMandatoryServiceNames[i] = xMandatoryServiceTypeDescriptions[i].getName(); + } + + } + } + } catch ( java.lang.Exception e) { + System.out.println(System.out); + } + return sMandatoryServiceNames; + } + + + private static String[] removeMandatoryServiceNames(String[] _sServiceNames){ + try{ + List aList = java.util.Arrays.asList(_sServiceNames); + Vector aVector = new Vector(aList); + for (int n = 0; n < _sServiceNames.length; n++){ + String[] sDelServiceNames = getMandatoryServiceNames(_sServiceNames[n]); + for (int m = 0; m < sDelServiceNames.length; m++){ + if (aVector.contains(sDelServiceNames[m])){ + int nIndex = aVector.indexOf(sDelServiceNames[m]); + aVector.remove(nIndex); + } + } + } + String[] sRetArray = new String[aVector.size()]; + aVector.toArray(sRetArray); + return sRetArray; + } catch (java.lang.Exception exception) { + exception.printStackTrace(System.out); + } + return new String[]{}; + } + + + 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) { +// assert sequenceType.getTypeClass() == TypeClass.SEQUENCE; + String n = sequenceType.getTypeName(); + final String PREFIX = "[]"; +// assert n.startsWith(PREFIX); + return new Type(n.substring(PREFIX.length())); + } + + + public static String getNodeDescription(Object _oUnoObject, int _nIndex){ + return getNodeDescription(_oUnoObject) + "[" + (_nIndex + 1) + "]"; + } + + + public static String getNodeDescription(Object _oUnoObject){ + XServiceInfo xServiceInfo = ( XServiceInfo ) UnoRuntime.queryInterface( XServiceInfo.class, _oUnoObject ); + if ( xServiceInfo != null ) { + return xServiceInfo.getImplementationName(); + } + String sClassName = _oUnoObject.getClass().getName(); + if (Introspector.getIntrospector().isObjectPrimitive(_oUnoObject)){ //super.isO{sObjectClassName.equals("java.lang.String"))issClassName.equals("java.lang.String")) + return _oUnoObject.toString(); + } + else{ + return _oUnoObject.getClass().getName(); + } + } + + public void setParameterObjects(Object[] _oParamObjects){ + m_oParamObjects = _oParamObjects; + } + + public Object[] getParameterObjects(){ + return m_oParamObjects; + } +} |