org.eclipse.viatra2.editor/src/org/eclipse/viatra2/treeeditor/properties/VPMPropertySource.java - viatra/org.eclipse.viatra2.vpm - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004-2008 Istvan Rath and Daniel Varro
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Istvan Rath - initial API and implementation
  *******************************************************************************/

  package org.eclipse.viatra2.treeeditor.properties;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Set;

 import org.eclipse.ui.views.properties.ComboBoxPropertyDescriptor;
 import org.eclipse.ui.views.properties.IPropertyDescriptor;
 import org.eclipse.ui.views.properties.IPropertySource2;
 import org.eclipse.ui.views.properties.PropertyDescriptor;
 import org.eclipse.ui.views.properties.TextPropertyDescriptor;
 import org.eclipse.viatra2.core.IEntity;
 import org.eclipse.viatra2.core.IModelElement;
 import org.eclipse.viatra2.core.IRelation;
 import org.eclipse.viatra2.tags.ITag;
 import org.eclipse.viatra2.tags.TagKind;
 import org.eclipse.viatra2.treeeditor.ViatraTreeEditor;
 import org.eclipse.viatra2.treeeditor.commands.AddSupertypeCommand;
 import org.eclipse.viatra2.treeeditor.commands.AddTypeCommand;
 import org.eclipse.viatra2.treeeditor.commands.ChangeElementNameCommand;
 import org.eclipse.viatra2.treeeditor.commands.ChangePropertyCommand;
 import org.eclipse.viatra2.treeeditor.commands.MoveModelElementCommand;
 import org.eclipse.viatra2.treeeditor.commands.RemoveSupertypeCommand;
 import org.eclipse.viatra2.treeeditor.commands.RemoveTypeCommand;
 import org.eclipse.viatra2.treeeditor.commands.RetargetRelationCommand;
 import org.eclipse.viatra2.treeeditor.commands.ViatraCompoundCommand;
 import org.eclipse.viatra2.treeeditor.commands.ViatraEditorCommand;
 import org.eclipse.viatra2.treeeditor.properties.descriptors.FQNListPropertyDescriptor;
 import org.eclipse.viatra2.treeeditor.properties.descriptors.FQNPropertyDescriptor;
 import org.eclipse.viatra2.treeeditor.properties.util.LabelTranslator;
 import org.eclipse.viatra2.treeeditor.properties.util.LegacyHelper;
 import org.eclipse.viatra2.treeeditor.properties.validators.DelimitedFQNListValidator;
 import org.eclipse.viatra2.treeeditor.properties.validators.FQNValidator;
 import org.eclipse.viatra2.treeeditor.properties.validators.LocalNameValidator;

 public class VPMPropertySource implements IPropertySource2
 {

 	static final String[] boolChoice = new String[]{"false","true"};
 	static final String[] multiplicityChoice = new String[]{"many to many","many to one","one to many","one to one"}; // important order

 	IModelElement iElement;
 	ViatraTreeEditor iEditor;

 	public VPMPropertySource(IModelElement e,ViatraTreeEditor ed)
 	{
 		iElement = e;
 		iEditor = ed;
 	}


 	public boolean isPropertyResettable(Object id) {
 		return false;
 	}

 	/*
 	 * Return true if the property has changed from the default value.
 	 */
 	public boolean isPropertySet(Object id)
 	{
 		return false;
 	}

 	public Object getEditableValue()
 	{
 		return null;
 	}

 	public IPropertyDescriptor[] getPropertyDescriptors()
 	{
 		ArrayList<IPropertyDescriptor> r = new ArrayList<IPropertyDescriptor>();
 		PropertyDescriptor d = null;

 		/* NAMING_VALUES */

 		d = new TextPropertyDescriptor(VPMProperties.NAME,LabelTranslator.getPropertyName(VPMProperties.NAME));
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
 		d.setValidator(new LocalNameValidator(iElement));
 		r.add(d);

 		// TextPropertyDescriptor to allow for easier copy-paste
 		d = new TextPropertyDescriptor(VPMProperties.FQN,LabelTranslator.getPropertyName(VPMProperties.FQN));
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
 		r.add(d);

 		d = new PropertyDescriptor(VPMProperties.WARNINGS,LabelTranslator.getPropertyName(VPMProperties.WARNINGS));
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TAGS));
 		r.add(d);

 		d = new PropertyDescriptor(VPMProperties.INFOTAGS,LabelTranslator.getPropertyName(VPMProperties.INFOTAGS));
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TAGS));
 		r.add(d);


 		if (iElement.isEntity())
 		{
 			d = new TextPropertyDescriptor(VPMProperties.VALUE,LabelTranslator.getPropertyName(VPMProperties.VALUE));
 			d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
 			r.add(d);
 		}

 		d = new TextPropertyDescriptor(VPMProperties.VIEWINFO,LabelTranslator.getPropertyName(VPMProperties.VIEWINFO));
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
 		r.add(d);

 		/* TYPES_SUPERTYPES */

 		d = new FQNListPropertyDescriptor(VPMProperties.TYPE,LabelTranslator.getPropertyName(VPMProperties.TYPE),iElement);
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
 		d.setValidator(new DelimitedFQNListValidator(iElement));
 		r.add(d);

 		d = new FQNListPropertyDescriptor(VPMProperties.SUPERTYPE,LabelTranslator.getPropertyName(VPMProperties.SUPERTYPE),iElement);
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
 		d.setValidator(new DelimitedFQNListValidator(iElement));
 		r.add(d);

 		d = new FQNListPropertyDescriptor(VPMProperties.INSTANCE,LabelTranslator.getPropertyName(VPMProperties.INSTANCE),iElement);
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
 		d.setValidator(new DelimitedFQNListValidator(iElement));
 		r.add(d);

 		d = new FQNListPropertyDescriptor(VPMProperties.SUBTYPE,LabelTranslator.getPropertyName(VPMProperties.SUBTYPE),iElement);
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
 		d.setValidator(new DelimitedFQNListValidator(iElement));
 		r.add(d);

 		d = new ComboBoxPropertyDescriptor(VPMProperties.ISFINALTYPE,LabelTranslator.getPropertyName(VPMProperties.ISFINALTYPE),
 				boolChoice);
 		d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
 		r.add(d);

 		/* RELATIONS */

 		if (iElement.isRelation())
 		{
 			d = new FQNPropertyDescriptor(VPMProperties.SOURCE,LabelTranslator.getPropertyName(VPMProperties.SOURCE),iElement);
 			d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
 			d.setValidator(new FQNValidator(iElement));
 			r.add(d);

 			d = new FQNPropertyDescriptor(VPMProperties.TARGET,LabelTranslator.getPropertyName(VPMProperties.TARGET),iElement);
 			d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
 			d.setValidator(new FQNValidator(iElement));
 			r.add(d);

 			d = new ComboBoxPropertyDescriptor(VPMProperties.ISAGGREGATION,LabelTranslator.getPropertyName(VPMProperties.ISAGGREGATION),boolChoice);
 			d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
 			r.add(d);

 			d = new ComboBoxPropertyDescriptor(VPMProperties.MULTIPLICITY,LabelTranslator.getPropertyName(VPMProperties.MULTIPLICITY),multiplicityChoice);
 			d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
 			r.add(d);
 		}

 		return r.toArray(new IPropertyDescriptor[]{});
 	}

 	static Integer Int0 = new Integer(0);
 	static Integer Int1 = new Integer(1);
 	static String EmptyString = new String("");

 	public Object getPropertyValue(Object id) {
 		try {
 			switch ( ((VPMProperties)id) )
 			{
 			case NAME: return iElement.getName();
 			case FQN: return iElement.getFullyQualifiedName();
 			case VALUE: return ((IEntity)iElement).getValue();
 			case VIEWINFO: return iElement.getViewInfo()!=null?iElement.getViewInfo():EmptyString;
 			case TYPE: return LegacyHelper.getTypesAsString(iElement); // FIXME change me
 			case INSTANCE: return LegacyHelper.getInstancesAsString(iElement);
 			case SUPERTYPE: return LegacyHelper.getSupertypesAsString(iElement);
 			case SUBTYPE: return LegacyHelper.getSubtypesAsString(iElement);
 			case ISFINALTYPE: return iElement.getIsFinalType()?Int1:Int0;
 			case SOURCE: return ((IRelation)iElement).getFrom().getFullyQualifiedName();
 			case TARGET: return ((IRelation)iElement).getTo().getFullyQualifiedName();
 			case ISAGGREGATION: return ((IRelation)iElement).getIsAggregation()?Int1:Int0;
 			case MULTIPLICITY: return ((IRelation)iElement).getMultiplicity().ordinal();
 			case WARNINGS:
 				String warnings = "";
 				Set<ITag> tags = iEditor.getFramework().getTagManager().getTagsForModelElement(iElement);
 				if (tags!=null)
 				{
 					for (ITag t : tags)
 					{
 						if (t.getKind().equals(TagKind.MODELING_PROBLEM))
 							warnings += t.getMessage()+"; ";
 					}
 				}
 				return warnings;
 			case INFOTAGS:
 				String infos = "";
 				Set<ITag> _tags = iEditor.getFramework().getTagManager().getTagsForModelElement(iElement);
 				if (_tags!=null)
 				{
 					for (ITag t : _tags)
 					{
 						if (t.getKind().equals(TagKind.MODELING_INFO))
 							infos += t.getMessage()+"; ";
 					}
 				}
 				return infos;
 			}
 		}
 		catch (Throwable t) {
 			// swallow nullpointers in case of invalid element references
 		}
 		return null;
 	}

 	public void resetPropertyValue(Object id) { }

 	@SuppressWarnings("unchecked")
 	public void setPropertyValue(Object id, Object value) {
 		ViatraEditorCommand cmd = null;
 		switch ( ((VPMProperties)id) )
 		{
 		case NAME:
 			ChangeElementNameCommand c = new ChangeElementNameCommand();
 			c.setNewElemName(value.toString());
 			c.setTargetElem(iElement);
 			cmd = c;
 			break;
 		case VALUE:
 			ChangePropertyCommand c1 = new ChangePropertyCommand();
 			c1.setKind(VPMProperties.VALUE);
 			c1.setNewValue(value.toString());
 			c1.setTarget(iElement);
 			cmd = c1;
 			break;
 		case VIEWINFO:
 			ChangePropertyCommand c2 = new ChangePropertyCommand();
 			c2.setKind(VPMProperties.VIEWINFO);
 			c2.setNewValue(value.toString());
 			c2.setTarget(iElement);
 			cmd = c2;
 			break;
 		case ISFINALTYPE:
 			ChangePropertyCommand c3 = new ChangePropertyCommand();
 			c3.setKind(VPMProperties.ISFINALTYPE);
 			c3.setIntValue((Integer)value);
 			c3.setTarget(iElement);
 			cmd = c3;
 			break;
 		case ISAGGREGATION:
 			ChangePropertyCommand c4 = new ChangePropertyCommand();
 			c4.setKind(VPMProperties.ISAGGREGATION);
 			c4.setIntValue((Integer)value);
 			c4.setTarget(iElement);
 			cmd = c4;
 			break;
 		case MULTIPLICITY:
 			ChangePropertyCommand c5 = new ChangePropertyCommand();
 			c5.setKind(VPMProperties.MULTIPLICITY);
 			c5.setIntValue((Integer)value);
 			c5.setTarget(iElement);
 			cmd = c5;
 			break;
 		case SOURCE:
 			// check if valid
 			IModelElement newSrc =
 				iElement.getModelSpace().getModelManager().getElementByName(value.toString());
 			if (newSrc!=null)
 			{
 				MoveModelElementCommand c6 = new MoveModelElementCommand();
 				c6.setRelation((IRelation)iElement,newSrc);
 				cmd = c6;
 			}
 			break;
 		case TARGET:
 			// check if valid
 			IModelElement newTrg =
 				iElement.getModelSpace().getModelManager().getElementByName(value.toString());
 			if (newTrg!=null)
 			{
 				RetargetRelationCommand c7 = new RetargetRelationCommand();
 				c7.setRelation((IRelation)iElement,newTrg);
 				cmd = c7;
 			}
 			break;
 		case TYPE:
 			if (true)
 			{
 				Set<IModelElement> newSet = clean_split(value.toString());
 				if (newSet==null) return; // error
 				HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
 				oldSet.addAll(iElement.getTypes());
 				HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
 				oldSet.removeAll(newSet);
 				newSet.removeAll(_oldSet);
 				// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
 				ViatraCompoundCommand cc = new ViatraCompoundCommand();
 				for (IModelElement staleType : oldSet)
 				{
 					RemoveTypeCommand _c = new RemoveTypeCommand();
 					_c.setTargetElem(iElement);
 					_c.setTypeElem(staleType);
 					cc.add(_c);
 				}
 				for (IModelElement newType : newSet)
 				{
 					AddTypeCommand _c = new AddTypeCommand();
 					_c.setTargetElem(iElement);
 					_c.setTypeElem(newType);
 					cc.add(_c);
 				}
 				cmd = cc;
 			}
 			break;
 		case INSTANCE:
 			if (true)
 			{
 				Set<IModelElement> newSet = clean_split(value.toString());
 				if (newSet==null) return; // error
 				HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
 				oldSet.addAll(iElement.getInstances());
 				HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
 				oldSet.removeAll(newSet);
 				newSet.removeAll(_oldSet);
 				// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
 				ViatraCompoundCommand cc = new ViatraCompoundCommand();
 				for (IModelElement staleType : oldSet)
 				{
 					RemoveTypeCommand _c = new RemoveTypeCommand();
 					_c.setTargetElem(staleType);
 					_c.setTypeElem(iElement);
 					cc.add(_c);
 				}
 				for (IModelElement newType : newSet)
 				{
 					AddTypeCommand _c = new AddTypeCommand();
 					_c.setTargetElem(newType);
 					_c.setTypeElem(iElement);
 					cc.add(_c);
 				}
 				cmd = cc;
 			}
 			break;
 		case SUPERTYPE:
 			if (true)
 			{
 				Set<IModelElement> newSet = clean_split(value.toString());
 				if (newSet==null) return; // error
 				HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
 				oldSet.addAll(iElement.getSupertypes());
 				HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
 				oldSet.removeAll(newSet);
 				newSet.removeAll(_oldSet);
 				// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
 				ViatraCompoundCommand cc = new ViatraCompoundCommand();
 				for (IModelElement staleType : oldSet)
 				{
 					RemoveSupertypeCommand _c = new RemoveSupertypeCommand();
 					_c.setTargetElem(iElement);
 					_c.setSupertypeElem(staleType);
 					cc.add(_c);
 				}
 				for (IModelElement newType : newSet)
 				{
 					AddSupertypeCommand _c = new AddSupertypeCommand();
 					_c.setTargetElem(iElement);
 					_c.setSupertypeElem(newType);
 					cc.add(_c);
 				}
 				cmd = cc;
 			}
 			break;
 		case SUBTYPE:
 			if (true)
 			{
 				Set<IModelElement> newSet = clean_split(value.toString());
 				if (newSet==null) return; // error
 				HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
 				oldSet.addAll(iElement.getSubtypes());
 				HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
 				oldSet.removeAll(newSet);
 				newSet.removeAll(_oldSet);
 				// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
 				ViatraCompoundCommand cc = new ViatraCompoundCommand();
 				for (IModelElement staleType : oldSet)
 				{
 					RemoveSupertypeCommand _c = new RemoveSupertypeCommand();
 					_c.setTargetElem(staleType);
 					_c.setSupertypeElem(iElement);
 					cc.add(_c);
 				}
 				for (IModelElement newType : newSet)
 				{
 					AddSupertypeCommand _c = new AddSupertypeCommand();
 					_c.setTargetElem(newType);
 					_c.setSupertypeElem(iElement);
 					cc.add(_c);
 				}
 				cmd = cc;
 			}
 			break;
 		}

 		if (cmd!=null) iEditor.getCommandStack().execute(cmd);
 	}

 	private Set<IModelElement> clean_split(String s)
 	{
 		String[] elements = s.replaceAll("[\\s]", "").split("[,;]");
 		return LegacyHelper.convertStringArrayToSetOfElements(elements, false, iElement.getModelSpace().getModelManager());
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004-2008 Istvan Rath and Daniel Varro
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Istvan Rath - initial API and implementation
	*******************************************************************************/

	package org.eclipse.viatra2.treeeditor.properties;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Set;

	import org.eclipse.ui.views.properties.ComboBoxPropertyDescriptor;
	import org.eclipse.ui.views.properties.IPropertyDescriptor;
	import org.eclipse.ui.views.properties.IPropertySource2;
	import org.eclipse.ui.views.properties.PropertyDescriptor;
	import org.eclipse.ui.views.properties.TextPropertyDescriptor;
	import org.eclipse.viatra2.core.IEntity;
	import org.eclipse.viatra2.core.IModelElement;
	import org.eclipse.viatra2.core.IRelation;
	import org.eclipse.viatra2.tags.ITag;
	import org.eclipse.viatra2.tags.TagKind;
	import org.eclipse.viatra2.treeeditor.ViatraTreeEditor;
	import org.eclipse.viatra2.treeeditor.commands.AddSupertypeCommand;
	import org.eclipse.viatra2.treeeditor.commands.AddTypeCommand;
	import org.eclipse.viatra2.treeeditor.commands.ChangeElementNameCommand;
	import org.eclipse.viatra2.treeeditor.commands.ChangePropertyCommand;
	import org.eclipse.viatra2.treeeditor.commands.MoveModelElementCommand;
	import org.eclipse.viatra2.treeeditor.commands.RemoveSupertypeCommand;
	import org.eclipse.viatra2.treeeditor.commands.RemoveTypeCommand;
	import org.eclipse.viatra2.treeeditor.commands.RetargetRelationCommand;
	import org.eclipse.viatra2.treeeditor.commands.ViatraCompoundCommand;
	import org.eclipse.viatra2.treeeditor.commands.ViatraEditorCommand;
	import org.eclipse.viatra2.treeeditor.properties.descriptors.FQNListPropertyDescriptor;
	import org.eclipse.viatra2.treeeditor.properties.descriptors.FQNPropertyDescriptor;
	import org.eclipse.viatra2.treeeditor.properties.util.LabelTranslator;
	import org.eclipse.viatra2.treeeditor.properties.util.LegacyHelper;
	import org.eclipse.viatra2.treeeditor.properties.validators.DelimitedFQNListValidator;
	import org.eclipse.viatra2.treeeditor.properties.validators.FQNValidator;
	import org.eclipse.viatra2.treeeditor.properties.validators.LocalNameValidator;

	public class VPMPropertySource implements IPropertySource2
	{

	static final String[] boolChoice = new String[]{"false","true"};
	static final String[] multiplicityChoice = new String[]{"many to many","many to one","one to many","one to one"}; // important order

	IModelElement iElement;
	ViatraTreeEditor iEditor;

	public VPMPropertySource(IModelElement e,ViatraTreeEditor ed)
	{
	iElement = e;
	iEditor = ed;
	}


	public boolean isPropertyResettable(Object id) {
	return false;
	}

	/*
	* Return true if the property has changed from the default value.
	*/
	public boolean isPropertySet(Object id)
	{
	return false;
	}

	public Object getEditableValue()
	{
	return null;
	}

	public IPropertyDescriptor[] getPropertyDescriptors()
	{
	ArrayList<IPropertyDescriptor> r = new ArrayList<IPropertyDescriptor>();
	PropertyDescriptor d = null;

	/* NAMING_VALUES */

	d = new TextPropertyDescriptor(VPMProperties.NAME,LabelTranslator.getPropertyName(VPMProperties.NAME));
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
	d.setValidator(new LocalNameValidator(iElement));
	r.add(d);

	// TextPropertyDescriptor to allow for easier copy-paste
	d = new TextPropertyDescriptor(VPMProperties.FQN,LabelTranslator.getPropertyName(VPMProperties.FQN));
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
	r.add(d);

	d = new PropertyDescriptor(VPMProperties.WARNINGS,LabelTranslator.getPropertyName(VPMProperties.WARNINGS));
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TAGS));
	r.add(d);

	d = new PropertyDescriptor(VPMProperties.INFOTAGS,LabelTranslator.getPropertyName(VPMProperties.INFOTAGS));
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TAGS));
	r.add(d);


	if (iElement.isEntity())
	{
	d = new TextPropertyDescriptor(VPMProperties.VALUE,LabelTranslator.getPropertyName(VPMProperties.VALUE));
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
	r.add(d);
	}

	d = new TextPropertyDescriptor(VPMProperties.VIEWINFO,LabelTranslator.getPropertyName(VPMProperties.VIEWINFO));
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.NAMING_VALUES));
	r.add(d);

	/* TYPES_SUPERTYPES */

	d = new FQNListPropertyDescriptor(VPMProperties.TYPE,LabelTranslator.getPropertyName(VPMProperties.TYPE),iElement);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
	d.setValidator(new DelimitedFQNListValidator(iElement));
	r.add(d);

	d = new FQNListPropertyDescriptor(VPMProperties.SUPERTYPE,LabelTranslator.getPropertyName(VPMProperties.SUPERTYPE),iElement);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
	d.setValidator(new DelimitedFQNListValidator(iElement));
	r.add(d);

	d = new FQNListPropertyDescriptor(VPMProperties.INSTANCE,LabelTranslator.getPropertyName(VPMProperties.INSTANCE),iElement);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
	d.setValidator(new DelimitedFQNListValidator(iElement));
	r.add(d);

	d = new FQNListPropertyDescriptor(VPMProperties.SUBTYPE,LabelTranslator.getPropertyName(VPMProperties.SUBTYPE),iElement);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
	d.setValidator(new DelimitedFQNListValidator(iElement));
	r.add(d);

	d = new ComboBoxPropertyDescriptor(VPMProperties.ISFINALTYPE,LabelTranslator.getPropertyName(VPMProperties.ISFINALTYPE),
	boolChoice);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.TYPES_SUPERTYPES));
	r.add(d);

	/* RELATIONS */

	if (iElement.isRelation())
	{
	d = new FQNPropertyDescriptor(VPMProperties.SOURCE,LabelTranslator.getPropertyName(VPMProperties.SOURCE),iElement);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
	d.setValidator(new FQNValidator(iElement));
	r.add(d);

	d = new FQNPropertyDescriptor(VPMProperties.TARGET,LabelTranslator.getPropertyName(VPMProperties.TARGET),iElement);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
	d.setValidator(new FQNValidator(iElement));
	r.add(d);

	d = new ComboBoxPropertyDescriptor(VPMProperties.ISAGGREGATION,LabelTranslator.getPropertyName(VPMProperties.ISAGGREGATION),boolChoice);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
	r.add(d);

	d = new ComboBoxPropertyDescriptor(VPMProperties.MULTIPLICITY,LabelTranslator.getPropertyName(VPMProperties.MULTIPLICITY),multiplicityChoice);
	d.setCategory(LabelTranslator.getCategoryName(VPMPropertyCategory.RELATIONS));
	r.add(d);
	}

	return r.toArray(new IPropertyDescriptor[]{});
	}

	static Integer Int0 = new Integer(0);
	static Integer Int1 = new Integer(1);
	static String EmptyString = new String("");

	public Object getPropertyValue(Object id) {
	try {
	switch ( ((VPMProperties)id) )
	{
	case NAME: return iElement.getName();
	case FQN: return iElement.getFullyQualifiedName();
	case VALUE: return ((IEntity)iElement).getValue();
	case VIEWINFO: return iElement.getViewInfo()!=null?iElement.getViewInfo():EmptyString;
	case TYPE: return LegacyHelper.getTypesAsString(iElement); // FIXME change me
	case INSTANCE: return LegacyHelper.getInstancesAsString(iElement);
	case SUPERTYPE: return LegacyHelper.getSupertypesAsString(iElement);
	case SUBTYPE: return LegacyHelper.getSubtypesAsString(iElement);
	case ISFINALTYPE: return iElement.getIsFinalType()?Int1:Int0;
	case SOURCE: return ((IRelation)iElement).getFrom().getFullyQualifiedName();
	case TARGET: return ((IRelation)iElement).getTo().getFullyQualifiedName();
	case ISAGGREGATION: return ((IRelation)iElement).getIsAggregation()?Int1:Int0;
	case MULTIPLICITY: return ((IRelation)iElement).getMultiplicity().ordinal();
	case WARNINGS:
	String warnings = "";
	Set<ITag> tags = iEditor.getFramework().getTagManager().getTagsForModelElement(iElement);
	if (tags!=null)
	{
	for (ITag t : tags)
	{
	if (t.getKind().equals(TagKind.MODELING_PROBLEM))
	warnings += t.getMessage()+"; ";
	}
	}
	return warnings;
	case INFOTAGS:
	String infos = "";
	Set<ITag> _tags = iEditor.getFramework().getTagManager().getTagsForModelElement(iElement);
	if (_tags!=null)
	{
	for (ITag t : _tags)
	{
	if (t.getKind().equals(TagKind.MODELING_INFO))
	infos += t.getMessage()+"; ";
	}
	}
	return infos;
	}
	}
	catch (Throwable t) {
	// swallow nullpointers in case of invalid element references
	}
	return null;
	}

	public void resetPropertyValue(Object id) { }

	@SuppressWarnings("unchecked")
	public void setPropertyValue(Object id, Object value) {
	ViatraEditorCommand cmd = null;
	switch ( ((VPMProperties)id) )
	{
	case NAME:
	ChangeElementNameCommand c = new ChangeElementNameCommand();
	c.setNewElemName(value.toString());
	c.setTargetElem(iElement);
	cmd = c;
	break;
	case VALUE:
	ChangePropertyCommand c1 = new ChangePropertyCommand();
	c1.setKind(VPMProperties.VALUE);
	c1.setNewValue(value.toString());
	c1.setTarget(iElement);
	cmd = c1;
	break;
	case VIEWINFO:
	ChangePropertyCommand c2 = new ChangePropertyCommand();
	c2.setKind(VPMProperties.VIEWINFO);
	c2.setNewValue(value.toString());
	c2.setTarget(iElement);
	cmd = c2;
	break;
	case ISFINALTYPE:
	ChangePropertyCommand c3 = new ChangePropertyCommand();
	c3.setKind(VPMProperties.ISFINALTYPE);
	c3.setIntValue((Integer)value);
	c3.setTarget(iElement);
	cmd = c3;
	break;
	case ISAGGREGATION:
	ChangePropertyCommand c4 = new ChangePropertyCommand();
	c4.setKind(VPMProperties.ISAGGREGATION);
	c4.setIntValue((Integer)value);
	c4.setTarget(iElement);
	cmd = c4;
	break;
	case MULTIPLICITY:
	ChangePropertyCommand c5 = new ChangePropertyCommand();
	c5.setKind(VPMProperties.MULTIPLICITY);
	c5.setIntValue((Integer)value);
	c5.setTarget(iElement);
	cmd = c5;
	break;
	case SOURCE:
	// check if valid
	IModelElement newSrc =
	iElement.getModelSpace().getModelManager().getElementByName(value.toString());
	if (newSrc!=null)
	{
	MoveModelElementCommand c6 = new MoveModelElementCommand();
	c6.setRelation((IRelation)iElement,newSrc);
	cmd = c6;
	}
	break;
	case TARGET:
	// check if valid
	IModelElement newTrg =
	iElement.getModelSpace().getModelManager().getElementByName(value.toString());
	if (newTrg!=null)
	{
	RetargetRelationCommand c7 = new RetargetRelationCommand();
	c7.setRelation((IRelation)iElement,newTrg);
	cmd = c7;
	}
	break;
	case TYPE:
	if (true)
	{
	Set<IModelElement> newSet = clean_split(value.toString());
	if (newSet==null) return; // error
	HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
	oldSet.addAll(iElement.getTypes());
	HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
	oldSet.removeAll(newSet);
	newSet.removeAll(_oldSet);
	// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
	ViatraCompoundCommand cc = new ViatraCompoundCommand();
	for (IModelElement staleType : oldSet)
	{
	RemoveTypeCommand _c = new RemoveTypeCommand();
	_c.setTargetElem(iElement);
	_c.setTypeElem(staleType);
	cc.add(_c);
	}
	for (IModelElement newType : newSet)
	{
	AddTypeCommand _c = new AddTypeCommand();
	_c.setTargetElem(iElement);
	_c.setTypeElem(newType);
	cc.add(_c);
	}
	cmd = cc;
	}
	break;
	case INSTANCE:
	if (true)
	{
	Set<IModelElement> newSet = clean_split(value.toString());
	if (newSet==null) return; // error
	HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
	oldSet.addAll(iElement.getInstances());
	HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
	oldSet.removeAll(newSet);
	newSet.removeAll(_oldSet);
	// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
	ViatraCompoundCommand cc = new ViatraCompoundCommand();
	for (IModelElement staleType : oldSet)
	{
	RemoveTypeCommand _c = new RemoveTypeCommand();
	_c.setTargetElem(staleType);
	_c.setTypeElem(iElement);
	cc.add(_c);
	}
	for (IModelElement newType : newSet)
	{
	AddTypeCommand _c = new AddTypeCommand();
	_c.setTargetElem(newType);
	_c.setTypeElem(iElement);
	cc.add(_c);
	}
	cmd = cc;
	}
	break;
	case SUPERTYPE:
	if (true)
	{
	Set<IModelElement> newSet = clean_split(value.toString());
	if (newSet==null) return; // error
	HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
	oldSet.addAll(iElement.getSupertypes());
	HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
	oldSet.removeAll(newSet);
	newSet.removeAll(_oldSet);
	// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
	ViatraCompoundCommand cc = new ViatraCompoundCommand();
	for (IModelElement staleType : oldSet)
	{
	RemoveSupertypeCommand _c = new RemoveSupertypeCommand();
	_c.setTargetElem(iElement);
	_c.setSupertypeElem(staleType);
	cc.add(_c);
	}
	for (IModelElement newType : newSet)
	{
	AddSupertypeCommand _c = new AddSupertypeCommand();
	_c.setTargetElem(iElement);
	_c.setSupertypeElem(newType);
	cc.add(_c);
	}
	cmd = cc;
	}
	break;
	case SUBTYPE:
	if (true)
	{
	Set<IModelElement> newSet = clean_split(value.toString());
	if (newSet==null) return; // error
	HashSet<IModelElement> oldSet = new HashSet<IModelElement>();
	oldSet.addAll(iElement.getSubtypes());
	HashSet<IModelElement> _oldSet = (HashSet<IModelElement>)oldSet.clone();
	oldSet.removeAll(newSet);
	newSet.removeAll(_oldSet);
	// now, all elements in newSet need to be added, and all elements in oldSet need to be removed
	ViatraCompoundCommand cc = new ViatraCompoundCommand();
	for (IModelElement staleType : oldSet)
	{
	RemoveSupertypeCommand _c = new RemoveSupertypeCommand();
	_c.setTargetElem(staleType);
	_c.setSupertypeElem(iElement);
	cc.add(_c);
	}
	for (IModelElement newType : newSet)
	{
	AddSupertypeCommand _c = new AddSupertypeCommand();
	_c.setTargetElem(newType);
	_c.setSupertypeElem(iElement);
	cc.add(_c);
	}
	cmd = cc;
	}
	break;
	}

	if (cmd!=null) iEditor.getCommandStack().execute(cmd);
	}

	private Set<IModelElement> clean_split(String s)
	{
	String[] elements = s.replaceAll("[\\s]", "").split("[,;]");
	return LegacyHelper.convertStringArrayToSetOfElements(elements, false, iElement.getModelSpace().getModelManager());
	}
	}