/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.uno.Any;
import com.sun.star.uno.AnyConverter;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.uno.TypeClass;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.Type;
import com.sun.star.uno.XComponentContext;
import com.sun.star.beans.XIntrospectionAccess;
import com.sun.star.beans.Property;
import com.sun.star.beans.PropertyValue;
import com.sun.star.beans.XPropertySet;
import com.sun.star.reflection.XIdlMethod;
import javax.swing.tree.ExpandVetoException;
import org.openoffice.XInstanceInspector;
import javax.swing.tree.TreePath;
import javax.swing.event.TreeWillExpandListener;
public class InspectorPane extends WeakBase implements XInstanceInspector{ //, XServiceInfo
private XIdlMethod[] xIdlMethods;
private Property[] aProperties;
private boolean bIncludeContent = false;
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.
* @param xMultiServiceFactory XMultiServiceFactory
*/
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);
}
private void setMaximumOfProgressBar(Object _oUnoObject){
int nMaxValue = 0;
xIdlMethods = m_oIntrospector.getMethods(_oUnoObject);
aProperties = m_oIntrospector.getProperties(_oUnoObject);
}
/** Inspect the given object for methods, properties, interfaces, and
* services.
* @param a 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.out);
}}
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 (m_oIntrospector.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 = m_oIntrospector.getShortClassName(aReturnObject.getType().getTypeName());
sNodeDescription += m_oSourceCodeGenerator.getVariableNameforUnoObject(sShortClassName);
}
if (m_oIntrospector.isArray(oUnoReturnObject)){
if (m_oIntrospector.isUnoTypeObject(oUnoReturnObject)){
oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SINTERFACEDESCRIPTION, _oUnoMethodNode.getUnoObject());
}
else if(m_oIntrospector.isUnoPropertyTypeObject(oUnoReturnObject)){
oUnoNode = addUnoFacetteNode(_oUnoMethodNode, XUnoFacetteNode.SPROPERTYINFODESCRIPTION, oUnoReturnObject);
}
else if(m_oIntrospector.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, 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);
}
public void addMethodsToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoParentObject, XIdlMethod[] _xIdlMethods){
if (this.m_oIntrospector.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)){
XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SMETHODDESCRIPTION, _oUnoObject);
}
if (m_oIntrospector.hasProperties(_oUnoObject)){
XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SPROPERTYDESCRIPTION, _oUnoObject);
}
if (m_oIntrospector.hasInterfaces(_oUnoObject)){
XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SINTERFACEDESCRIPTION, _oUnoObject);
}
if (m_oIntrospector.isContainer(_oUnoObject)){
XUnoFacetteNode oUnoFacetteNode = addUnoFacetteNode(_oParentNode, XUnoFacetteNode.SCONTAINERDESCRIPTION, _oUnoObject);
}
if (m_oIntrospector.hasSupportedServices(_oUnoObject)){
XUnoFacetteNode oUnoFacetteNode = 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.out);
}}
// add all services for the given object to the tree under the node parent
private void addServicesToTreeNode(XUnoNode _oGrandParentNode, Object _oUnoObject) {
try{
XServiceInfo 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.out);
}}
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 = ( 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.out);
}}
public void addContainerElementsToTreeNode(XUnoNode _oParentNode, Object _oUnoParentObject){
Object[] oUnoContainerElements = m_oIntrospector.getUnoObjectsOfContainer(_oUnoParentObject);
if (m_oIntrospector.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 (!m_oIntrospector.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 (m_oIntrospector.isObjectPrimitive(object[i])){
XUnoNode oChildNode = addUnoNode(_oUnoNode, null, UnoNode.getNodeDescription(object[i]));
}
}
}
else{
String[] sDisplayValues = UnoNode.getDisplayValuesofPrimitiveArray(_oUnoObject);
for ( int i = 0; i < sDisplayValues.length; i++ ) {
XUnoNode oUnoNode = 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 (m_oIntrospector.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 (! m_oIntrospector.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, XTreePathProvider _xTreePathProvider){
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{
//TOOD this code is redundant!!!
if ( oUnoObject.getClass().isArray()){
// TOODO probably we should provid 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 distinguishe the different UnoFacetteNodes only by the nodedescription
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()){
// TOODO probably we should provid 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);
}
/** In opposition to 'getUnoObjectOfTreeNode' this method inspects the passed node if it represents a Uno object
* If not it returns null
*
*/
private Object getUnoObjectOfExplicitTreeNode(XTreePathProvider _xTreePathProvider){
XUnoNode oUnoNode = _xTreePathProvider.getLastPathComponent();
if (oUnoNode != null){
return oUnoNode.getUnoObject();
}
return null;
}
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;
}
/** In opposition to 'getUnoObjectOfexplictTreeNode' this method inspects the passed node if it represents a Uno object
* if not it keeps checking all ancestors until it finds a Uno representation
*/
private Object getUnoObjectOfTreeNode(XTreePathProvider _xTreePathProvider){
XTreePathProvider xTreePathProvider = _xTreePathProvider;
HideableMutableTreeNode oNode = null;
Object oUnoObject = null;
while (xTreePathProvider != null){
oUnoObject = getUnoObjectOfExplicitTreeNode(xTreePathProvider);
if (oUnoObject != null){
if (oUnoObject instanceof String){
}
else{
if (!m_oIntrospector.isUnoTypeObject(oUnoObject)){
return oUnoObject;
}
}
}
xTreePathProvider = xTreePathProvider.getParentPath();
}
return null;
}
public void showPopUpMenu(Object _invoker, int x, int y) throws ClassCastException{
XUnoNode oUnoNode = getSelectedNode();
boolean bdoEnableInvoke = oUnoNode instanceof XUnoMethodNode;
// boolean bdoEnableSourceCodeGeneration = true;
if (bdoEnableInvoke){
XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode;
bdoEnableInvoke = oUnoMethodNode.isInvokable();
// bdoEnableSourceCodeGeneration = bdoEnableInvoke;
}
m_xDialogProvider.enablePopupMenuItem(XDialogProvider.SINVOKE, bdoEnableInvoke);
// m_xDialogProvider.enablePopupMenuItem(XDialogProvider.SADDTOSOURCECODE, bdoEnableSourceCodeGeneration);
m_xDialogProvider.showPopUpMenu(_invoker, x, y);
}
}