odk/examples/java/Inspector/InspectorPane.java

   1 /*************************************************************************
   2  *
   3  *  The Contents of this file are made available subject to the terms of
   4  *  the BSD license.
   5  *
   6  *  Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *  All rights reserved.
   8  *
   9  *  Redistribution and use in source and binary forms, with or without
  10  *  modification, are permitted provided that the following conditions
  11  *  are met:
  12  *  1. Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  *  2. Redistributions in binary form must reproduce the above copyright
  15  *     notice, this list of conditions and the following disclaimer in the
  16  *     documentation and/or other materials provided with the distribution.
  17  *  3. Neither the name of Sun Microsystems, Inc. nor the names of its
  18  *     contributors may be used to endorse or promote products derived
  19  *     from this software without specific prior written permission.
  20  *
  21  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  28  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  29  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  30  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  31  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  *************************************************************************/
  34
  35
  36 import org.openoffice.XInstanceInspector;
  37
  38 import com.sun.star.beans.Property;
  39 import com.sun.star.beans.PropertyValue;
  40 import com.sun.star.beans.XIntrospectionAccess;
  41 import com.sun.star.beans.XPropertySet;
  42 import com.sun.star.lang.XServiceInfo;
  43 import com.sun.star.lib.uno.helper.WeakBase;
  44 import com.sun.star.reflection.XIdlMethod;
  45 import com.sun.star.uno.Any;
  46 import com.sun.star.uno.AnyConverter;
  47 import com.sun.star.uno.Type;
  48 import com.sun.star.uno.TypeClass;
  49 import com.sun.star.uno.UnoRuntime;
  50 import com.sun.star.uno.XComponentContext;
  51
  52     public class InspectorPane extends WeakBase implements XInstanceInspector{  //, XServiceInfo
  53         private XIdlMethod[] xIdlMethods;
  54         private Property[] aProperties;
  55         private boolean bIncludeContent = false;
  56         private XComponentContext m_xComponentContext;
  57         private XDialogProvider m_xDialogProvider;
  58         private Introspector m_oIntrospector = null;
  59         private SourceCodeGenerator m_oSourceCodeGenerator;
  60         private XTreeControlProvider m_xTreeControlProvider;
  61         private String sTitle = "";
  62
  63
  64         /** The constructor of the inner class has a XMultiServiceFactory parameter.
  65          * @param xMultiServiceFactory XMultiServiceFactory
  66          */
  67         public InspectorPane(XComponentContext _xComponentContext, XDialogProvider _xDialogProvider, XTreeControlProvider _xTreeControlProvider, int _nLanguage) {
  68             m_xComponentContext = _xComponentContext;
  69             m_xTreeControlProvider = _xTreeControlProvider;
  70             m_xDialogProvider = _xDialogProvider;
  71             m_oIntrospector = Introspector.getIntrospector(m_xComponentContext);
  72             m_oSourceCodeGenerator = new SourceCodeGenerator(_nLanguage);
  73             _xTreeControlProvider.addInspectorPane(this);
  74         }
  75
  76
  77         private void setMaximumOfProgressBar(Object _oUnoObject){
  78             int nMaxValue = 0;
  79             xIdlMethods = m_oIntrospector.getMethods(_oUnoObject);
  80             aProperties = m_oIntrospector.getProperties(_oUnoObject);
  81         }
  82
  83
  84         /** Inspect the given object for methods, properties, interfaces, and
  85          * services.
  86          * @param a The object to inspect
  87          * @throws RuntimeException If
  88          */
  89         public void inspect(java.lang.Object _oUserDefinedObject, String _sTitle) throws com.sun.star.uno.RuntimeException {
  90         try {
  91             Object oContainer = m_xTreeControlProvider.inspect(_oUserDefinedObject, _sTitle);
  92             m_xDialogProvider.addInspectorPage(getTitle(), oContainer);
  93         }
  94         catch( Exception exception ) {
  95             exception.printStackTrace(System.err);
  96         }}
  97
  98
  99         public void setTitle(String _sTitle){
 100             if (_sTitle != null){
 101                 if (_sTitle.length() > 0){
 102                     sTitle = _sTitle;
 103                 }
 104             }
 105         }
 106
 107
 108         public String getTitle(){
 109             return sTitle;
 110         }
 111
 112
 113
 114         private Type[] getTypes(Object _oUnoObject){
 115             Type[] aTypes = null;
 116             if (AnyConverter.isArray(_oUnoObject)){
 117                 aTypes = (Type[])_oUnoObject;
 118             }
 119             else{
 120                 aTypes = m_oIntrospector.getInterfaces(_oUnoObject);
 121             }
 122             return aTypes;
 123         }
 124
 125
 126         private Object invoke(XUnoMethodNode _oUnoMethodNode){
 127         try{
 128             String sParamValueDescription = "";
 129             Object oUnoReturnObject = _oUnoMethodNode.invoke();
 130             boolean bHasParameters = _oUnoMethodNode.hasParameters();
 131             boolean bIsPrimitive = _oUnoMethodNode.isPrimitive();
 132                 if (bHasParameters){
 133                     sParamValueDescription = " (" + m_oSourceCodeGenerator.getMethodParameterValueDescription(_oUnoMethodNode, _oUnoMethodNode.getLastParameterObjects(), true) + ")";
 134                 }
 135             if (oUnoReturnObject != null ){
 136                 String sNodeDescription = "";
 137                 XUnoNode oUnoNode = null;
 138                 if (_oUnoMethodNode.getXIdlMethod().getReturnType().getTypeClass().getValue() == TypeClass.VOID_value){
 139                     sNodeDescription += _oUnoMethodNode.getXIdlMethod().getReturnType().getName() + " " + _oUnoMethodNode.getXIdlMethod().getName() + sParamValueDescription;
 140                     _oUnoMethodNode.setLabel(sNodeDescription);
 141                     m_xTreeControlProvider.nodeChanged(_oUnoMethodNode);
 142                 }
 143                 else if (bHasParameters || !bIsPrimitive){
 144                     if (bIsPrimitive){
 145                         sNodeDescription += m_oSourceCodeGenerator.getStringValueOfObject(oUnoReturnObject, _oUnoMethodNode.getTypeClass());
 146                     }
 147                     else{
 148                         Any aReturnObject = Any.complete(oUnoReturnObject);
 149                         String sShortClassName = Introspector.getShortClassName(aReturnObject.getType().getTypeName());
 150                         sNodeDescription += m_oSourceCodeGenerator.getVariableNameforUnoObject(sShortClassName);
 151                     }
 152                     if (Introspector.isArray(oUnoReturnObject)){
 153                         if (Introspector.isUnoTypeObject(oUnoReturnObject)){
 154                             oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SINTERFACEDESCRIPTION, _oUnoMethodNode.getUnoObject());
 155                         }
 156                         else if(Introspector.isUnoPropertyTypeObject(oUnoReturnObject)){
 157                             oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SPROPERTYINFODESCRIPTION, oUnoReturnObject);
 158                         }
 159                         else if(Introspector.isUnoPropertyValueTypeObject(oUnoReturnObject)){
 160                             oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SPROPERTYVALUEDESCRIPTION, oUnoReturnObject);
 161                         }
 162                     }
 163                     if (oUnoNode == null){
 164                         if (bHasParameters){
 165                             sNodeDescription += sParamValueDescription;
 166                         }
 167                         oUnoNode = addUnoNode(null, oUnoReturnObject, sNodeDescription);
 168                         if (bHasParameters){
 169                             oUnoNode.setParameterObjects(_oUnoMethodNode.getLastParameterObjects());
 170                         }
 171                     }
 172                     if (oUnoNode != null){
 173                         oUnoNode.setFoldable(!bIsPrimitive);
 174                         _oUnoMethodNode.setFoldable(false);
 175                         _oUnoMethodNode.addChildNode(oUnoNode);
 176                         m_xTreeControlProvider.nodeInserted(_oUnoMethodNode, oUnoNode, _oUnoMethodNode.getChildCount()-1);
 177                     }
 178                 }
 179                 else{
 180                     if (bIsPrimitive){
 181                         sNodeDescription  = _oUnoMethodNode.getStandardMethodDescription() + "=" + UnoMethodNode.getDisplayValueOfPrimitiveType(oUnoReturnObject);
 182                         _oUnoMethodNode.setLabel(sNodeDescription);
 183                         m_xTreeControlProvider.nodeChanged(_oUnoMethodNode);
 184                     }
 185                 }
 186             }
 187             // ReturnObject of method node == null..
 188             else{
 189                 if (!bHasParameters){
 190                     _oUnoMethodNode.setLabel(_oUnoMethodNode.getLabel() + " = null");
 191                 }
 192                 else{
 193                     _oUnoMethodNode.setLabel(_oUnoMethodNode.getXIdlMethod().getName() + sParamValueDescription + " = null");
 194                 }
 195                 m_xTreeControlProvider.nodeChanged(_oUnoMethodNode);
 196             }
 197             return oUnoReturnObject;
 198         }catch(Exception exception ) {
 199             return null;
 200         }}
 201
 202
 203         public void invokeSelectedMethodNode(){
 204             XTreePathProvider xTreePathProvider = m_xTreeControlProvider.getSelectedPath();
 205             XUnoNode oUnoNode = xTreePathProvider.getLastPathComponent();
 206             if (oUnoNode instanceof XUnoMethodNode){
 207                 invoke((XUnoMethodNode) oUnoNode);
 208                 m_xTreeControlProvider.expandPath(xTreePathProvider);
 209             }
 210         }
 211
 212
 213         public void addSourceCodeOfSelectedNode(){
 214             XTreePathProvider oTreePathProvider = m_xTreeControlProvider.getSelectedPath();
 215             XUnoNode oUnoNode = oTreePathProvider.getLastPathComponent();
 216             if (oUnoNode instanceof XUnoMethodNode){
 217                 XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode;
 218                 if (!oUnoMethodNode.isInvoked() && oUnoMethodNode.isInvokable()){
 219                     invoke(oUnoMethodNode);
 220                 }
 221             }
 222             String sSourceCode = m_oSourceCodeGenerator.addSourceCodeOfUnoObject(oTreePathProvider, true, true, true);
 223             m_xTreeControlProvider.setSourceCode(sSourceCode);
 224         }
 225
 226
 227         public void convertCompleteSourceCode(int _nLanguage){
 228             String sSourceCode = m_oSourceCodeGenerator.convertAllUnoObjects(_nLanguage);
 229             m_xTreeControlProvider.setSourceCode(sSourceCode);
 230         }
 231
 232         protected XUnoNode getSelectedNode(){
 233             return m_xTreeControlProvider.getSelectedNode();
 234         }
 235
 236
 237         //  add the object to the hashtable for a possible access in the tree
 238         private  XUnoFacetteNode addUnoFacetteNode(XUnoNode _oParentNode, String _sNodeDescription, Object _oUnoObject){
 239             return m_xTreeControlProvider.addUnoFacetteNode( _oParentNode, _sNodeDescription, _oUnoObject);
 240         }
 241
 242
 243         private XUnoMethodNode addMethodNode(Object _objectElement, XIdlMethod _xIdlMethod){
 244             return m_xTreeControlProvider.addMethodNode(_objectElement, _xIdlMethod);
 245         }
 246
 247
 248
 249         public void addMethodsToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoParentObject, XIdlMethod[] _xIdlMethods){
 250             if (Introspector.isValid(_xIdlMethods)){
 251                 for ( int n = 0; n < _xIdlMethods.length; n++ ) {
 252                     XIdlMethod xIdlMethod = _xIdlMethods[n];
 253                     if (!xIdlMethod.getDeclaringClass().getName().equals("com.sun.star.uno.XInterface")){
 254                         XUnoMethodNode oChildNode = addMethodNode(_oUnoParentObject, xIdlMethod);
 255                         if (oChildNode != null){
 256                             _oGrandParentNode.addChildNode(oChildNode);
 257                         }
 258                     }
 259                 }
 260             }
 261         }
 262
 263
 264         private void addFacetteNodesToTreeNode(XUnoNode _oParentNode, Object _oUnoObject){
 265             if (m_oIntrospector.hasMethods(_oUnoObject)){
 266                 XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SMETHODDESCRIPTION, _oUnoObject);
 267             }
 268             if (m_oIntrospector.hasProperties(_oUnoObject)){
 269                 XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SPROPERTYDESCRIPTION, _oUnoObject);
 270             }
 271             if (m_oIntrospector.hasInterfaces(_oUnoObject)){
 272                 XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SINTERFACEDESCRIPTION, _oUnoObject);
 273             }
 274             if (m_oIntrospector.isContainer(_oUnoObject)){
 275                 XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SCONTAINERDESCRIPTION, _oUnoObject);
 276             }
 277             if (m_oIntrospector.hasSupportedServices(_oUnoObject)){
 278                 XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SSERVICEDESCRIPTION, _oUnoObject);
 279             }
 280         }
 281
 282
 283         private void addInterfacesToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoParentObject, Type[] _aTypes) {
 284         try {
 285             if (_oUnoParentObject != null){
 286                 for ( int m = 0; m < _aTypes.length; m++ ) {
 287                     addUnoNode(_oGrandParentNode, _oUnoParentObject, _aTypes[m]);
 288                 }
 289             }
 290         }
 291         catch( Exception exception ) {
 292             exception.printStackTrace(System.err);
 293         }}
 294
 295
 296         //  add all services for the given object to the tree under the node parent
 297         private void addServicesToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoObject) {
 298         try{
 299             XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _oUnoObject );
 300             if ( xServiceInfo != null ){
 301                 String[] sSupportedServiceNames = xServiceInfo.getSupportedServiceNames();
 302                 for ( int m = 0; m < sSupportedServiceNames.length; m++ ) {
 303                     String sServiceName = sSupportedServiceNames[m];
 304                     if (sServiceName.length() > 0){
 305                         XUnoNode oUnoNode = addUnoNode(_oGrandParentNode, _oUnoObject, sSupportedServiceNames[m]);
 306                         oUnoNode.setNodeType(XUnoNode.nSERVICE);
 307                     }
 308                 }
 309             }
 310         }
 311         catch(Exception exception) {
 312             exception.printStackTrace(System.err);
 313         }}
 314
 315
 316         private void addPropertiesAndInterfacesOfService(XUnoNode _oUnoServiceNode){
 317             String sServiceName  = _oUnoServiceNode.getClassName();
 318             Object oUnoObject = _oUnoServiceNode.getUnoObject();
 319             addInterfacesToTreeNode(_oUnoServiceNode, oUnoObject, m_oIntrospector.getInterfaces(oUnoObject, sServiceName));
 320             addPropertiesToTreeNode(_oUnoServiceNode, oUnoObject, m_oIntrospector.getProperties(oUnoObject, sServiceName));
 321         }
 322
 323
 324     private void addPropertiesToTreeNode(XUnoNode _oParentNode, Object _oUnoParentObject,  Property[] _aProperties) {
 325     try {
 326         if (_aProperties.length > 0){
 327             for ( int n = 0; n < _aProperties.length; n++ ){
 328                 Property aProperty = _aProperties[n];
 329                 XIntrospectionAccess xIntrospectionAccess = m_oIntrospector.getXIntrospectionAccess(_oUnoParentObject);
 330                 XPropertySet xPropertySet = UnoRuntime.queryInterface( XPropertySet.class, xIntrospectionAccess.queryAdapter(new Type( XPropertySet.class)));
 331                 if (xPropertySet != null) {
 332                     if (xPropertySet.getPropertySetInfo().hasPropertyByName(aProperty.Name)){
 333                         Object objectElement = xPropertySet.getPropertyValue(aProperty.Name);
 334                         if (objectElement != null) {
 335                             XUnoNode oChildNode = m_xTreeControlProvider.addUnoPropertyNode(_oUnoParentObject, aProperty, objectElement);
 336                             if (oChildNode != null){
 337                                 _oParentNode.addChildNode(oChildNode);
 338                             }
 339                         }
 340                     }
 341                 }
 342             }
 343         }
 344     }
 345     catch(Exception exception) {
 346         exception.printStackTrace(System.err);
 347     }}
 348
 349
 350     public void addContainerElementsToTreeNode(XUnoNode _oParentNode, Object _oUnoParentObject){
 351         Object[] oUnoContainerElements = m_oIntrospector.getUnoObjectsOfContainer(_oUnoParentObject);
 352         if (Introspector.isValid(oUnoContainerElements)){
 353             if (oUnoContainerElements.length > 0){
 354                 for (int i=0; i< oUnoContainerElements.length; i++){
 355                     XUnoNode oChildNode = addUnoNode(_oParentNode, oUnoContainerElements[i], UnoNode.getNodeDescription(oUnoContainerElements[i]));
 356                     m_xTreeControlProvider.nodeInserted(_oParentNode, oChildNode, _oParentNode.getChildCount()-1);
 357                 }
 358             }
 359         }
 360     }
 361
 362
 363     private XUnoNode addUnoNode(XUnoNode _oParentNode, Object _oUnoObject, String _sLabel ){
 364         XUnoNode oUnoNode = this.m_xTreeControlProvider.addUnoNode(_oUnoObject);
 365         oUnoNode.setLabel(_sLabel);
 366         if (_oParentNode != null){
 367             _oParentNode.addChildNode(oUnoNode);
 368         }
 369         setNodeFoldable(oUnoNode, _oUnoObject);
 370         return oUnoNode;
 371     }
 372
 373
 374     private void setNodeFoldable(XUnoNode _oUnoNode, Object _oUnoObject){
 375         if (_oUnoObject != null){
 376             if (!Introspector.isObjectPrimitive(_oUnoObject)){
 377                 _oUnoNode.setFoldable(true);
 378             }
 379         }
 380     }
 381
 382
 383     private XUnoNode addUnoNode(XUnoNode _oParentNode, Object _oUnoObject, Type _aType){
 384         XUnoNode oUnoNode = this.m_xTreeControlProvider.addUnoNode(_oUnoObject, _aType);
 385         if (_oParentNode != null){
 386             _oParentNode.addChildNode(oUnoNode);
 387         }
 388         setNodeFoldable(oUnoNode, _oUnoObject);
 389         return oUnoNode;
 390     }
 391
 392
 393     private void addPropertySetInfoNodesToTreeNode(XUnoFacetteNode _oUnoFacetteNode, Object _oUnoObject){
 394         if (_oUnoObject.getClass().isArray()){
 395             Object[] object = ( Object[] ) _oUnoObject;
 396             for ( int i = 0; i < object.length; i++ ) {
 397                 Property aProperty = (Property) object[i];
 398                 XUnoPropertyNode oUnoPropertyNode = m_xTreeControlProvider.addUnoPropertyNode(_oUnoObject, aProperty);
 399                 oUnoPropertyNode.setLabel(XUnoFacetteNode.SPROPERTYINFODESCRIPTION + " (" + aProperty.Name + ")");
 400                 oUnoPropertyNode.setFoldable(true);
 401                 _oUnoFacetteNode.addChildNode(oUnoPropertyNode);
 402             }
 403         }
 404     }
 405
 406     private void addPrimitiveValuesToTreeNode(XUnoNode _oUnoNode, Object _oUnoObject){
 407         if (_oUnoObject.getClass().isArray()){
 408             if (!_oUnoObject.getClass().getComponentType().isPrimitive()){
 409                 Object[] object = ( Object[] ) _oUnoObject;
 410                 for ( int i = 0; i < object.length; i++ ) {
 411                     if (Introspector.isObjectPrimitive(object[i])){
 412                         XUnoNode oChildNode = addUnoNode(_oUnoNode, null, UnoNode.getNodeDescription(object[i]));
 413                     }
 414                 }
 415             }
 416             else{
 417                 String[] sDisplayValues = UnoNode.getDisplayValuesofPrimitiveArray(_oUnoObject);
 418                 for ( int i = 0; i < sDisplayValues.length; i++ ) {
 419                     XUnoNode oUnoNode = addUnoNode(_oUnoNode, null, sDisplayValues[i]);
 420                 }
 421             }
 422         }
 423     }
 424
 425
 426     private void addPropertySetInfoSubNodes(XUnoPropertyNode _oUnoPropertyNode){
 427         Property aProperty = _oUnoPropertyNode.getProperty();
 428         _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithName(aProperty));
 429         _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithType(aProperty));
 430         _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithHandle(aProperty));
 431         _oUnoPropertyNode.addChildNode(m_xTreeControlProvider.addUnoPropertyNodeWithAttributesDescription(aProperty));
 432     }
 433
 434
 435     private void addPropertyValueSubNodes(XUnoFacetteNode _oUnoFacetteNode, Object _oUnoObject){
 436         if (Introspector.isUnoPropertyValueTypeObject(_oUnoObject)){
 437             Object[] object = ( Object[] ) _oUnoObject;
 438             for ( int i = 0; i < object.length; i++ ) {
 439                 String sObjectClassName = object[i].getClass().getName();
 440                 if (sObjectClassName.equals("com.sun.star.beans.PropertyValue")){
 441                     XUnoNode oChildNode = null;
 442                     PropertyValue aPropertyValue = (PropertyValue) object[i];
 443                     if (! Introspector.isObjectPrimitive(aPropertyValue.Value)){
 444                         oChildNode = m_xTreeControlProvider.addUnoPropertyNode(_oUnoObject, aPropertyValue, _oUnoObject);
 445                     }
 446                     else{
 447                         oChildNode = addUnoNode(null, aPropertyValue.Value, UnoPropertyNode.getStandardPropertyValueDescription(aPropertyValue));
 448                     }
 449                     if (oChildNode != null){
 450                         _oUnoFacetteNode.addChildNode(oChildNode);
 451                     }
 452                 }
 453             }
 454         }
 455     }
 456
 457
 458     public boolean expandNode(XUnoNode _oUnoNode, XTreePathProvider _xTreePathProvider){
 459         if ( _oUnoNode != null ) {
 460             _oUnoNode.setFoldable(false);
 461             if (m_xTreeControlProvider.isMethodNode(_oUnoNode)){
 462                 XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) _oUnoNode;
 463                 if (!oUnoMethodNode.isInvoked()){
 464                     Object oUnoReturnObject = invoke((XUnoMethodNode) _oUnoNode);
 465                     if (oUnoReturnObject == null){
 466                         _oUnoNode.setFoldable(true);
 467                         return false;
 468                     }
 469                 }
 470             }
 471             else if (m_xTreeControlProvider.isPropertyNode(_oUnoNode)){
 472                 XUnoPropertyNode oUnoPropertyNode = (XUnoPropertyNode) _oUnoNode;
 473                 Object oUnoObject = oUnoPropertyNode.getUnoReturnObject();
 474                 if (oUnoPropertyNode.getPropertyNodeType() == XUnoPropertyNode.nPROPERTYSETINFOTYPE){
 475                     addPropertySetInfoSubNodes(oUnoPropertyNode);
 476                 }
 477                 else{
 478                     //TOOD this code is redundant!!!
 479                     if ( oUnoObject.getClass().isArray()){
 480                         // TOODO probably we should provid a possibility to insert also non-primitive nodes
 481                         addPrimitiveValuesToTreeNode(oUnoPropertyNode, oUnoObject);
 482                     }
 483                     else{
 484                         addFacetteNodesToTreeNode(oUnoPropertyNode, oUnoObject);
 485                     }
 486                 }
 487             }
 488             else if (m_xTreeControlProvider.isFacetteNode(_oUnoNode)){
 489                 XUnoFacetteNode oUnoFacetteNode = (XUnoFacetteNode) _oUnoNode;
 490                 Object oUnoObject = _oUnoNode.getUnoObject();
 491                 if (oUnoFacetteNode.isMethodNode()){
 492                     addMethodsToTreeNode(oUnoFacetteNode, oUnoObject, m_oIntrospector.getMethods(oUnoObject));
 493                 }
 494                 if (oUnoFacetteNode.isPropertyNode()){
 495                     String sNodeDescription = oUnoFacetteNode.getLabel();
 496                     // TODO: it's very dangerous to distinguish the different UnoFacetteNodes only by the node description
 497                     if (sNodeDescription.startsWith(XUnoFacetteNode.SPROPERTYINFODESCRIPTION)){
 498                         addPropertySetInfoNodesToTreeNode(oUnoFacetteNode, oUnoObject);
 499                     }
 500                     else if (sNodeDescription.startsWith(XUnoFacetteNode.SPROPERTYVALUEDESCRIPTION)){
 501                         addPropertyValueSubNodes(oUnoFacetteNode, oUnoObject);
 502                     }
 503                     else{
 504                         addPropertiesToTreeNode(oUnoFacetteNode, oUnoObject, m_oIntrospector.getProperties(oUnoObject));
 505                     }
 506                 }
 507                 if (oUnoFacetteNode.isServiceNode()){
 508                     addServicesToTreeNode(oUnoFacetteNode, oUnoObject);
 509                 }
 510                 if (oUnoFacetteNode.isInterfaceNode()){
 511                     addInterfacesToTreeNode(oUnoFacetteNode, oUnoObject, getTypes(oUnoObject));
 512                 }
 513                 if (oUnoFacetteNode.isContainerNode()){
 514                     addContainerElementsToTreeNode(oUnoFacetteNode, oUnoObject);
 515                 }
 516             }
 517             else if (_oUnoNode.getNodeType() == XUnoNode.nSERVICE){
 518                 addPropertiesAndInterfacesOfService(_oUnoNode);
 519             }
 520             else if (_oUnoNode.getNodeType() == XUnoNode.nINTERFACE){
 521                 Type aType = _oUnoNode.getUnoType();
 522                 if (aType != null){
 523                     addMethodsToTreeNode(_oUnoNode, _oUnoNode.getUnoObject(), m_oIntrospector.getMethodsOfInterface(aType));
 524                 }
 525             }
 526             else if (_oUnoNode.getNodeType() == XUnoNode.nOTHERS){
 527                 Object oUnoObject = _oUnoNode.getUnoObject();
 528                 if ( oUnoObject.getClass().isArray()){
 529                     // TOODO probably we should provid a possibility to insert also non-primitive nodes
 530                      addPrimitiveValuesToTreeNode(_oUnoNode, oUnoObject);
 531                 }
 532                 else{
 533                     addFacetteNodesToTreeNode(_oUnoNode, oUnoObject);
 534                 }
 535             }
 536         }
 537         return true;
 538     }
 539
 540
 541
 542         public void applyFilter(XUnoFacetteNode _oUnoFacetteNode, String _sFilter){
 543             for (int i = 0; i < _oUnoFacetteNode.getChildCount(); i++){
 544                 XUnoNode oUnoNode = _oUnoFacetteNode.getChild(i);
 545                 boolean bIsVisible = oUnoNode.isFilterApplicable(_sFilter);
 546                 m_xTreeControlProvider.setNodeVisible(oUnoNode, bIsVisible);
 547             }
 548             _oUnoFacetteNode.setFilter(_sFilter);
 549         }
 550
 551
 552         /** In opposition to 'getUnoObjectOfTreeNode' this method inspects the passed node if it represents a Uno object
 553          *  If not it returns null
 554          *
 555          */
 556         private Object getUnoObjectOfExplicitTreeNode(XTreePathProvider _xTreePathProvider){
 557             XUnoNode oUnoNode = _xTreePathProvider.getLastPathComponent();
 558             if (oUnoNode != null){
 559                 return oUnoNode.getUnoObject();
 560             }
 561             return null;
 562         }
 563
 564
 565         public String getFilter(XUnoNode _oUnoNode){
 566             String sFilter = "";
 567             if (_oUnoNode != null){
 568                 XUnoNode oUnoNode = _oUnoNode;
 569                 boolean bleaveLoop = false;
 570                 do{
 571                     if (m_xTreeControlProvider.isFacetteNode(oUnoNode)){
 572                         sFilter = ((XUnoFacetteNode) oUnoNode).getFilter();
 573                         bleaveLoop = true;
 574                     }
 575                     else{
 576                         if (oUnoNode.getParentNode() != null){
 577                             oUnoNode = oUnoNode.getParentNode();
 578                         }
 579                         else{
 580                             bleaveLoop = true;
 581                         }
 582                     }
 583                 } while(!bleaveLoop);
 584             }
 585             return sFilter;
 586         }
 587
 588
 589         /** In opposition to 'getUnoObjectOfexplictTreeNode' this method inspects the passed node if it represents a Uno object
 590          *  if not it keeps checking all ancestors until it finds a Uno representation
 591          */
 592         private Object getUnoObjectOfTreeNode(XTreePathProvider _xTreePathProvider){
 593             XTreePathProvider xTreePathProvider = _xTreePathProvider;
 594             HideableMutableTreeNode oNode = null;
 595             Object oUnoObject = null;
 596             while (xTreePathProvider != null){
 597                 oUnoObject = getUnoObjectOfExplicitTreeNode(xTreePathProvider);
 598                 if (oUnoObject != null){
 599                     if (oUnoObject instanceof String){
 600                     }
 601                     else{
 602                         if (!Introspector.isUnoTypeObject(oUnoObject)){
 603                             return oUnoObject;
 604                         }
 605                     }
 606                 }
 607                 xTreePathProvider = xTreePathProvider.getParentPath();
 608             }
 609             return null;
 610         }
 611
 612
 613         public void showPopUpMenu(Object _invoker, int x, int y) throws ClassCastException{
 614             XUnoNode oUnoNode = getSelectedNode();
 615             boolean bdoEnableInvoke = oUnoNode instanceof XUnoMethodNode;
 616 //            boolean bdoEnableSourceCodeGeneration = true;
 617             if (bdoEnableInvoke){
 618                 XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode;
 619                 bdoEnableInvoke = oUnoMethodNode.isInvokable();
 620 //                bdoEnableSourceCodeGeneration = bdoEnableInvoke;
 621             }
 622             m_xDialogProvider.enablePopupMenuItem(XDialogProvider.SINVOKE, bdoEnableInvoke);
 623 //            m_xDialogProvider.enablePopupMenuItem(XDialogProvider.SADDTOSOURCECODE, bdoEnableSourceCodeGeneration);
 624             m_xDialogProvider.showPopUpMenu(_invoker, x, y);
 625         }
 626 }