/**********************************************************************
 * This file is part of "Object Teams Development Tooling"-Software
 * 
 * Copyright 2005, 2007 Fraunhofer Gesellschaft, Munich, Germany,
 * for its Fraunhofer Institute for Computer Architecture and Software
 * Technology (FIRST), Berlin, Germany and Technical University Berlin,
 * Germany.
 * 
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * 
 * Please visit http://www.eclipse.org/objectteams for updates and contact.
 * 
 * Contributors:
 * Fraunhofer FIRST - Initial API and implementation
 * Technical University Berlin - Initial API and implementation
 **********************************************************************/
package org.eclipse.objectteams.otdt.internal.ui.bindingeditor;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AbstractMethodMappingDeclaration;
import org.eclipse.jdt.core.dom.CallinMappingDeclaration;
import org.eclipse.jdt.core.dom.CalloutMappingDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FieldAccessSpec;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.MethodMappingElement;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.ParameterMapping;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.QualifiedType;
import org.eclipse.jdt.core.dom.RoleTypeDeclaration;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.ui.ISharedImages;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
import org.eclipse.objectteams.otdt.ui.ImageManager;

/**
 * The main UI class of the binding editor.
 * 
 * @author jwloka
 */
public class BindingEditor extends Composite
{
    private IType _team; 
    final BindingConfiguration bindConfig;
    private Tree _connTableTree;
    private TabFolder _tabFolder;
    private CallinMappingConfiguration _callinMapConfig;
    private CalloutMappingConfiguration _calloutMapConfig;
    private TabItem _paraMapItem;
    private TabItem _methMapItem;
    // for tab folder switching
    private final TabItem[] _methMapItems;
    private final TabItem[] _paraMapItems;
    final TreeViewer _connTableViewer;
	private TypeDeclaration _rootTeam;
    
	/** Map single names to qualified names (only for bases of newly created roles. */
    HashMap<String,String> _baseClassLookup = new HashMap<String,String>();
	
    class TreeContentProvider implements IStructuredContentProvider, ITreeContentProvider 
    {
    	    	
    	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
    	public void dispose() {}
        
    	public Object[] getElements(Object inputElement) 
    	{
        	TypeDeclaration decl = (TypeDeclaration)inputElement;
        	return decl.getTypes();
    	}
        
    	public Object[] getChildren(Object parentElement) 
    	{
        	ASTNode node = (ASTNode)parentElement;
        	if (node.getNodeType() == ASTNode.ROLE_TYPE_DECLARATION) 
        	{
        		RoleTypeDeclaration roleNode = (RoleTypeDeclaration)node;
        		Object[] callouts = roleNode.getCallOuts();
        		Object[] callins = roleNode.getCallIns();
        		Object[] roles = roleNode.getRoles();
        		Object[] result = new Object[roles.length+callouts.length+callins.length];
        		System.arraycopy(roles, 0, result, 0, roles.length);
        		System.arraycopy(callouts, 0, result, roles.length, callouts.length);
        		System.arraycopy(callins, 0, result, roles.length+callouts.length, callins.length);
        		return result;
        	}
			else if (node.getNodeType() == ASTNode.CALLIN_MAPPING_DECLARATION 
			        	|| node.getNodeType() == ASTNode.CALLOUT_MAPPING_DECLARATION)
			{
				AbstractMethodMappingDeclaration mapping = 
					(AbstractMethodMappingDeclaration)node;
				List pMappings = mapping.getParameterMappings();
				return pMappings.toArray();
			}
			else
			{
				return new Object[]{};
			}
    	}
    	
        public Object getParent(Object element) 
        {
            return null;
        }
        
        public boolean hasChildren(Object element) 
        {
            return getChildren(element).length > 0;
        }
    }
    
    class LabelProvider extends WorkbenchLabelProvider implements ITableLabelProvider
	{
		private static final String INDENT = "    "; //$NON-NLS-1$
		private static final String PARAMETER_MAPPING_RIGHT = "->"; //$NON-NLS-1$
        private static final String EMPTY_TEXT = ""; //$NON-NLS-1$
        
        public void addListener(ILabelProviderListener listener) {}
		public void dispose() {}

		public boolean isLabelProperty(Object element, String property) 
		{
			return false;
		}

		public void removeListener(ILabelProviderListener listener) {}

		public Image getColumnImage(Object element, int columnIndex) 
		{
			ASTNode node = (ASTNode)element;
			switch (columnIndex) {
			case 0: // role column
				if (node.getNodeType() == ASTNode.ROLE_TYPE_DECLARATION) {
					if (((RoleTypeDeclaration)node).isTeam())
						return ImageManager.getSharedInstance().get(ImageManager.TEAM_ROLE_IMG);
					else
						return ImageManager.getSharedInstance().get(ImageManager.ROLECLASS_IMG);
				} 
				break;
			case 2: // base column
				if (node.getNodeType() == ASTNode.ROLE_TYPE_DECLARATION) {
					ITypeBinding binding= ((TypeDeclaration)node).resolveBinding();
					if (binding != null) 
						binding= binding.getBaseClass();
					if (binding != null) {
						if (binding.isRole()) {
							if (binding.isTeam())
								return ImageManager.getSharedInstance().get(ImageManager.TEAM_ROLE_IMG);
							else
								return ImageManager.getSharedInstance().get(ImageManager.ROLECLASS_IMG);							
						} else if (binding.isTeam()) {
							return ImageManager.getSharedInstance().get(ImageManager.TEAM_IMG);							
						}
					}
					return JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_CLASS);
				} else if (node.getNodeType() == ASTNode.CALLOUT_MAPPING_DECLARATION) {
					MethodMappingElement baseMappingElement = ((CalloutMappingDeclaration)node).getBaseMappingElement();
					if (baseMappingElement.getNodeType() == ASTNode.FIELD_ACCESS_SPEC)
					{
						IVariableBinding field= ((FieldAccessSpec)baseMappingElement).resolveBinding();
						if (field != null) {
							if (Modifier.isPublic(field.getModifiers()))
								return JavaUI.getSharedImages().getImage(ISharedImages.IMG_FIELD_PUBLIC);
							if (Modifier.isProtected(field.getModifiers()))
								return JavaUI.getSharedImages().getImage(ISharedImages.IMG_FIELD_PROTECTED);
							if (Modifier.isPrivate(field.getModifiers()))
								return JavaUI.getSharedImages().getImage(ISharedImages.IMG_FIELD_PRIVATE);
						}						
						return JavaUI.getSharedImages().getImage(ISharedImages.IMG_FIELD_DEFAULT);
					}
				}
				break;
			case 1: // mapping kind column
				switch (node.getNodeType()) {
				case ASTNode.CALLIN_MAPPING_DECLARATION:
					int callinModifier = ((CallinMappingDeclaration)element).getCallinModifier();
					if (Modifier.isAfter(callinModifier))
						return ImageManager.getSharedInstance().get(ImageManager.CALLINBINDING_AFTER_IMG);
					else if(Modifier.isBefore(callinModifier))
						return ImageManager.getSharedInstance().get(ImageManager.CALLINBINDING_BEFORE_IMG);
					else
						return ImageManager.getSharedInstance().get(ImageManager.CALLINBINDING_REPLACE_IMG);

				case ASTNode.CALLOUT_MAPPING_DECLARATION:
					return ImageManager.getSharedInstance().get(ImageManager.CALLOUTBINDING_IMG);
				
				case ASTNode.PARAMETER_MAPPING:
					ParameterMapping mapping = (ParameterMapping)element;
					if (mapping.getDirection().equals(PARAMETER_MAPPING_RIGHT))
						return ImageManager.getSharedInstance().get(ImageManager.CALLOUTBINDING_IMG);
					else
						return ImageManager.getSharedInstance().get(ImageManager.CALLINBINDING_REPLACE_IMG); // ups ;-)
				}
			}
			return null;
		}
		

		public String getColumnText(Object element, int columnIndex) 
		{
			ASTNode node = (ASTNode)element;
			switch (node.getNodeType()) 
			{
				case ASTNode.ROLE_TYPE_DECLARATION:
				{
					RoleTypeDeclaration role = (RoleTypeDeclaration)element;
					switch (columnIndex)
					{
						case 0:
							return role.getName().getIdentifier();
						case 1:
							return EMPTY_TEXT;
						case 2:
							Name baseClass = getRoleBaseClass(role);
							if (baseClass != null)
								return baseClass.getFullyQualifiedName();
							else 
								return EMPTY_TEXT;
						default:
							return EMPTY_TEXT;
					}
				}
				case ASTNode.CALLIN_MAPPING_DECLARATION:
				{
					CallinMappingDeclaration callinDecl = (CallinMappingDeclaration)element;
					switch (columnIndex)
					{
						case 0:
							return callinDecl.getRoleMappingElement().toString();
						case 1:
						    
						    if (Modifier.isAfter(callinDecl.getCallinModifier()))
							{
								return new String(IOTConstants.NAME_AFTER);
							}
							else if(Modifier.isBefore(callinDecl.getCallinModifier()))
							{
							    return new String(IOTConstants.NAME_BEFORE);
							}
							else if(Modifier.isReplace(callinDecl.getCallinModifier()))
							{
							    return new String(IOTConstants.NAME_REPLACE);
							}
							else
							{
							    return EMPTY_TEXT;
							}
						    
						    //orig:
							//return Modifier.ModifierKeyword.fromFlagValue(callinDecl.getModifiers()).toString();
						case 2:
							List baseMappingElements = callinDecl.getBaseMappingElements(); 
							String result = INDENT;
							for (int idx = 0; idx < baseMappingElements.size(); idx ++)
							{
								if (idx > 0)
								{
									result = result + ", "; //$NON-NLS-1$
								}
								result = result + baseMappingElements.get(idx).toString();
							}
							return result;
						default:
							return EMPTY_TEXT;
					}
				}
				case ASTNode.CALLOUT_MAPPING_DECLARATION:
				{
					CalloutMappingDeclaration callout = (CalloutMappingDeclaration)element;
					switch (columnIndex)
					{
						case 0:
							return callout.getRoleMappingElement().toString();
						case 1:
							return EMPTY_TEXT;
						case 2:
							return INDENT+callout.getBaseMappingElement().toString();
						default:
							return EMPTY_TEXT;
					}
				}	
				case ASTNode.PARAMETER_MAPPING:
				{
					ParameterMapping mapping = (ParameterMapping)element;
					switch (columnIndex)
					{
						case 0:
							if (mapping.getDirection().equals(PARAMETER_MAPPING_RIGHT))
								return mapping.getExpression().toString();
							else
				            	return mapping.getIdentifier().getIdentifier();
						case 1:
							return EMPTY_TEXT;
						case 2:
							if (mapping.getDirection().equals(PARAMETER_MAPPING_RIGHT))
								return INDENT+mapping.getIdentifier();
							else
								return INDENT+mapping.getExpression().toString();
						default:
							return EMPTY_TEXT;
					}
				}
				default:
				{
					return EMPTY_TEXT;
				}
			}
		}
	}
    
    
    public BindingEditor(final Composite parent, int style, final IType teamType, final CompilationUnit root)
    {
        super(parent, style);
        _team = teamType;
        calculateRootNode(root);
        
        setLayout(new FormLayout());

        final Group connDefGroup = new Group(this, SWT.NONE);
        connDefGroup.setText(Messages.BindingEditor_connector_title);
        final FormData formData = new FormData();
        formData.bottom = new FormAttachment(58, 0);
        formData.right = new FormAttachment(100, -5);
        formData.top = new FormAttachment(0, 5);
        formData.left = new FormAttachment(0, 5);
        connDefGroup.setLayoutData(formData);
        connDefGroup.setLayout(new FormLayout());

        _connTableViewer = new TreeViewer(connDefGroup, SWT.BORDER);
        _connTableViewer.setContentProvider(new TreeContentProvider());
        _connTableViewer.setLabelProvider(new LabelProvider());
        _connTableViewer.setAutoExpandLevel(2);
        
        _connTableTree = _connTableViewer.getTree();

        final FormData formData_2 = new FormData();
        formData_2.bottom = new FormAttachment(84, 0);
        formData_2.right = new FormAttachment(100, -5);
        formData_2.top = new FormAttachment(0, 5);
        formData_2.left = new FormAttachment(0, 5);
        _connTableTree.setLayoutData(formData_2);
        _connTableTree.addSelectionListener( new SelectionAdapter() 
        {
            public void widgetSelected(SelectionEvent evt) 
            {
                bindingTableSelectionChanged();
            }
         });
        
        _connTableTree.setLinesVisible(true);
        _connTableTree.setHeaderVisible(true);
        
        final TreeColumn rolesCol = new TreeColumn(_connTableTree, SWT.NONE);
        rolesCol.setWidth(300);
        rolesCol.setText(Messages.BindingEditor_role_types_title);

        final TreeColumn methMapColumn = new TreeColumn(_connTableTree, SWT.NONE);
        methMapColumn.setWidth(80);

        final TreeColumn baseCol = new TreeColumn(_connTableTree, SWT.NONE);
        baseCol.setWidth(300);
        baseCol.setText(Messages.BindingEditor_base_types_title);

		// Note(SH): need all columns set before retrieving contents by setInput()
        _connTableViewer.setInput(_rootTeam);
        
        final Composite buttonComp = new Composite(connDefGroup, SWT.NONE);
        final FormData formData_3 = new FormData();
        formData_3.bottom = new FormAttachment(100, -5);
        formData_3.right = new FormAttachment(100, -5);
        formData_3.top = new FormAttachment(_connTableTree, 5, SWT.BOTTOM);
        formData_3.left = new FormAttachment(_connTableTree, 0, SWT.LEFT);
        buttonComp.setLayoutData(formData_3);
        buttonComp.setLayout(new FormLayout());

        final Button addConnBtn = new Button(buttonComp, SWT.NONE);
        final FormData formData_4 = new FormData();
        formData_4.top = new FormAttachment(0, 5);
        formData_4.left = new FormAttachment(0, 5);
        addConnBtn.setLayoutData(formData_4);
        addConnBtn.setText(Messages.BindingEditor_add_type_binding_button);
        addConnBtn.addSelectionListener( new SelectionAdapter() 
        {
        	public void widgetSelected(SelectionEvent evt) 
        	{
                IType roleClass = null;
                
                AddTypeBindingDialog dlg =
                    AddTypeBindingDialog.create(parent.getShell(), teamType);
                if (AddTypeBindingDialog.OK == dlg.open()) 
                {
                    roleClass = dlg.getRoleType();
                }
                else
                {
                	return;
                }

                AST ast = _rootTeam.getAST();

                RoleTypeDeclaration role = ast.newRoleTypeDeclaration();
                role.setName(ast.newSimpleName(roleClass.getElementName()));
                role.setRole(true);
                try {
					int flags = roleClass.getFlags() & ~Modifier.ABSTRACT;
					role.modifiers().addAll(ast.newModifiers(flags));
				} catch (JavaModelException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
                String qualifiedBaseTypeName = dlg.getBaseTypeName();
				String[] identifiers = qualifiedBaseTypeName.split("\\."); //$NON-NLS-1$
                
                // use the single name for playedBy:
                int len = identifiers.length;
                String singleName = identifiers[len-1];
				role.setBaseClassType(ast.newSimpleType(ast.newName(singleName)));
				BindingEditor.this._baseClassLookup.put(singleName, qualifiedBaseTypeName);
              
                // add an import using the qualified name:
                _rootTeam.bodyDeclarations().add(role);
                ImportDeclaration baseImport = ast.newImportDeclaration();
                baseImport.setBase(true);
                baseImport.setName(ast.newName(identifiers));
                root.imports().add(baseImport);

                refresh();
                _connTableViewer.setSelection(new StructuredSelection(role));
                bindingTableSelectionChanged();
            }
        });

        final Button remConnBtn = new Button(buttonComp, SWT.NONE);
        final FormData formData_5 = new FormData();
        formData_5.top = new FormAttachment(addConnBtn, 0, SWT.TOP);
        formData_5.left = new FormAttachment(addConnBtn, 5, SWT.RIGHT);
        remConnBtn.setLayoutData(formData_5);
        remConnBtn.setText(Messages.BindingEditor_remove_button);
        remConnBtn.addSelectionListener( new SelectionAdapter() 
		{
			public void widgetSelected(SelectionEvent evt) 
			{
				removeElementsFromAST();
				refresh();
				bindConfig.resetLists();
			}
		});

        // TabFolder
        _tabFolder = new TabFolder(this, SWT.NONE);
        final FormData formData_1 = new FormData();
        formData_1.bottom = new FormAttachment(100, -5);
        formData_1.right = new FormAttachment(100, -5);
        formData_1.top = new FormAttachment(connDefGroup, 5, SWT.BOTTOM);
        formData_1.left = new FormAttachment(0, 5);
        _tabFolder.setLayoutData(formData_1);

        // method mapping tab item
        bindConfig = new BindingConfiguration(_tabFolder, SWT.NONE);
        bindConfig.setCurrentTeamForMethodFake(teamType);
        
        _methMapItem = new TabItem(_tabFolder, SWT.NONE);
        _methMapItem.setText(Messages.BindingEditor_method_binding_tab);
        _methMapItem.setControl(bindConfig);
        _methMapItems = new TabItem[] { _methMapItem };
        

        // parameter mapping tab item
        _callinMapConfig = new CallinMappingConfiguration(_tabFolder, SWT.NONE);
        _calloutMapConfig = new CalloutMappingConfiguration(_tabFolder, SWT.NONE);

        _paraMapItem = new TabItem(_tabFolder, SWT.NONE);
        _paraMapItem.setText(Messages.BindingEditor_param_mapping_tab);
        _paraMapItem.setControl(_callinMapConfig);
        _paraMapItems = new TabItem[] { _paraMapItem };
    }
    
	private void calculateRootNode(CompilationUnit cu) 
	{
	    // Note: we compare the source-start of the IType's name with the DOM node's simpleName's
	    // source-start, instead of using the type's start-position. This is because the IType's
	    // getSourceRange() method returns a different position than dom.TypeDeclaration.getStartPosition()
	    // depending on the type of comment before the type declaration (/** */ vs. /* */), so they
	    // didn't match.
	    
		try 
		{
			final TypeDeclaration[] teamDecl = new TypeDeclaration[1];
			final int teamPos = _team.getNameRange().getOffset();

			ASTVisitor visitor = new org.eclipse.jdt.internal.corext.dom.GenericVisitor() {
				public boolean visit(CompilationUnit node) {
					for (Iterator iter = node.types().iterator(); iter.hasNext();) {
						TypeDeclaration type = (TypeDeclaration) iter.next();
						if (!visit(type))
							return false;
					}
					return false;
				}
				
				public boolean visit(TypeDeclaration node) {
					int pos = node.getName().getStartPosition();
					if (pos == teamPos) {
						teamDecl[0] = node;
						return false;
					}

					TypeDeclaration[] memberTypes = node.getTypes();
					for (int i = 0; i < memberTypes.length; i++) {
						if (!visit(memberTypes[i]))
							return false;
					}
					
					return true;
				}
				
				public boolean visit(RoleTypeDeclaration node) {
					return visit ((TypeDeclaration) node);
				}

			};
			
			visitor.visit(cu);

			_rootTeam = teamDecl[0];
		} 
		catch (JavaModelException ex) {}
	}

	private void prepareParameterMappingConfiguration(
    		AbstractMethodMappingDeclaration methMap,
			ParameterMapping paraMap)
    {
        if (methMap == null)
        {
            _paraMapItem.setControl(null);
        }
		else if (methMap instanceof CallinMappingDeclaration)
        {
			_paraMapItem.setControl(_callinMapConfig);
			_callinMapConfig.setFocus(
                    paraMap,
					(CallinMappingDeclaration)methMap);
		}
        else if (methMap instanceof CalloutMappingDeclaration)
        {
			_paraMapItem.setControl(_calloutMapConfig);
			_calloutMapConfig.setFocus(
                    paraMap,
					(CalloutMappingDeclaration)methMap);
		}
	}
    
    private void removeElementsFromAST()
    {
		TreeItem[] selectedItems = _connTableTree.getSelection();
		ASTNode selectedNode = null;
	    
		for (int idx = 0; idx < selectedItems.length; idx++)
		{
			selectedNode = (ASTNode)selectedItems[idx].getData();
			
			if (selectedNode.getParent() instanceof TypeDeclaration)
			{
				removeElementFromAST(selectedNode);
			}
			else if(selectedNode.getParent() instanceof AbstractMethodMappingDeclaration)
			{
				removeElementFromAST((ParameterMapping)selectedNode);
			}
		}
    }

    /** Removes roles from teams and mappings from roles */
    private void removeElementFromAST(ASTNode selectedNode)
    {
    	TypeDeclaration parent = (TypeDeclaration)selectedNode.getParent();
		parent.bodyDeclarations().remove(selectedNode);
    }
    
    /** Removes ParameterMappings from callin or callout */
    private void removeElementFromAST(ParameterMapping selectedNode)
    {
        AbstractMethodMappingDeclaration abstractMethodMappingDeclaration = 
            (AbstractMethodMappingDeclaration)selectedNode.getParent();
        abstractMethodMappingDeclaration.getParameterMappings().remove(selectedNode);
    }

    protected void checkSubclass() {}
    
    private AbstractMethodMappingDeclaration getAbstractMethodMapping(ParameterMapping paraMap)
    {
        return (AbstractMethodMappingDeclaration)paraMap.getParent();
    }
    
    public void refresh()
    {
    	_connTableViewer.refresh();
    }

	public void bindingTableSelectionChanged() 
    {
		TreeItem[] selectedItems = _connTableTree.getSelection();
		ASTNode selectedNode = null;
		
		for (int idx = 0; idx < selectedItems.length; idx++)
		{
		    selectedNode = (ASTNode)selectedItems[idx].getData();
		    switch (selectedNode.getNodeType())
		    {
		        case ASTNode.ROLE_TYPE_DECLARATION:
		            RoleTypeDeclaration roleTypeDecl =
		                (RoleTypeDeclaration)selectedNode;

		            bindConfig.setFocusRole(roleTypeDecl, _team, true); 
		            prepareParameterMappingConfiguration(null, null);
		            _tabFolder.setSelection(_methMapItems);
		            break;
		        case ASTNode.CALLOUT_MAPPING_DECLARATION:
		            bindConfig.setCalloutMapping(selectedNode, _team);
		            prepareParameterMappingConfiguration(
		                    (AbstractMethodMappingDeclaration)selectedNode,
		                    null);
		            _tabFolder.setSelection(_methMapItems);
		            break;
		        case ASTNode.CALLIN_MAPPING_DECLARATION:
		        	bindConfig.setCallinMapping(selectedNode, _team);
		            prepareParameterMappingConfiguration(
		                (AbstractMethodMappingDeclaration)selectedNode,
		                null);
		            _tabFolder.setSelection(_methMapItems);
		            break;
		        case ASTNode.PARAMETER_MAPPING:
		            ParameterMapping paraMap =
		                (ParameterMapping)selectedNode;
		        
		            AbstractMethodMappingDeclaration methMap =
		                getAbstractMethodMapping(paraMap);
		            prepareParameterMappingConfiguration(methMap, paraMap);
		            
		            _tabFolder.setSelection(_paraMapItems);
		            break;
		        default:
		            break;
		    }
		}
	}

	public void methodBindingAdded(AbstractMethodMappingDeclaration mapping) 
	{
		_connTableViewer.expandToLevel(mapping.getParent(), 1);
		// Note(SH): do not select the new element, because this caused
		//           subsequent creation of method mappings to replace this method mapping.
		//           This problem annoyed us throughout all demos (Chicago) and tutorials (Erfurt, Bonn)!
		//_connTableViewer.setSelection(new StructuredSelection(mapping));
		bindingTableSelectionChanged();
	}
	
	private Name getRoleBaseClass(RoleTypeDeclaration element) {
        Name result = null;
    	Type baseType = element.getBaseClassType();
    	if(baseType != null) {
    		if (baseType.isParameterizedType())
         		baseType= ((ParameterizedType)baseType).getType();
        	if(baseType.isSimpleType())
        		result = ((SimpleType)baseType).getName();
        	else
        	if(baseType.isQualifiedType())
        		result = ((QualifiedType)baseType).getName();
        	else
        		assert false; // what's that?
    	}
        return result;
	}

	public boolean isRootTeam(TypeDeclaration currentType) {
		return this._rootTeam == currentType;
	}

}