437 lines
16 KiB
Java
437 lines
16 KiB
Java
/*************************************************************************
|
|
*
|
|
* 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;
|
|
}
|
|
}
|