/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: Diagram.java
   * Created: 2007-00-00
   * Author: fox, tmilos
   * $Id: Diagram.java 2770 2009-04-21 19:17:34Z kpietak $
   */
  
  package pl.edu.agh.cast.model.visual.backward;
  
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Date;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.log4j.Logger;
  import org.eclipse.core.resources.IFile;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IProgressMonitor;
  import org.eclipse.core.runtime.NullProgressMonitor;
  import org.eclipse.osgi.util.NLS;
  
  import pl.edu.agh.cast.Activator;
  import pl.edu.agh.cast.model.DefaultStatisticsProvider;
  import pl.edu.agh.cast.model.attributes.Attribute;
  import pl.edu.agh.cast.model.attributes.AttributeManager;
  import pl.edu.agh.cast.model.attributes.AttributeMergePolicy;
  import pl.edu.agh.cast.model.attributes.AttributeValue;
  import pl.edu.agh.cast.model.attributes.ConnectionGroupAttributeManager;
  import pl.edu.agh.cast.model.attributes.DiagramAttributeManager;
  import pl.edu.agh.cast.model.attributes.NodeAttributeManager;
  import pl.edu.agh.cast.model.attributes.ValueType;
  import pl.edu.agh.cast.model.base.DataSet;
  import pl.edu.agh.cast.model.base.IDataSet;
  import pl.edu.agh.cast.model.base.IEntity;
  import pl.edu.agh.cast.model.base.IRelation;
  import pl.edu.agh.cast.util.Messages;
  
  import com.thoughtworks.xstream.annotations.XStreamAlias;
  
  /**
   * Diagram, which consists of of {@link Node}s and {@link Connection}s.
   *
   * @author AGH CAST Team
   */
  @XStreamAlias("diagram")
  public class Diagram extends ModelElement implements IDiagram, PropertyChangeListener {
  
  	private static final long serialVersionUID = 7475870569424703697L;
  
  	/**
  	 * Default, dummy id of diagrams editor.
  	 */
  	public static final String DUMMY_ID = "dummyEditorId"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Diagram name changed</em> event.
  	 */
  	public static final String NAME = "Diagram.NAME"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Diagram file changed</em> event.
  	 */
  	public static final String FILE = "Diagram.FILE"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Diagram node added/removed</em> event.
  	 */
  	public static final String CHILD = "Diagram.CHILD"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Diagram connections changed</em> event.
  	 */
  	public static final String CONNECTION = "Diagram.CONNECTION"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Diagram nodes (multiple) added/removed</em> event.
  	 */
  	public static final String CHILDREN = "Diagram.CHILDREN"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Diagram nodes deselected</em> event.
  	 */
  	public static final String DESELECT = "Diagram.DESELECT"; //$NON-NLS-1$
 
 	/**
 	 * Logger for this class.
 	 */
 	protected static Logger log = Activator.getLogger();
 
 	/**
 	 * File this diagram is stored in.
 	 */
 	protected transient IFile file;
 
 	private boolean enhancable = false;
 
 	/**
 	 * Diagram settings.
 	 */
 	@XStreamAlias("settings")
 	protected IDiagramSettings settings;
 
 	/**
 	 * Node attribute manager.
 	 */
 	@XStreamAlias("nodeAttributes")
 	protected NodeAttributeManager nodeAttributeManager;
 
 	/**
 	 * Connection group attribute manager.
 	 */
 	@XStreamAlias("connectionGroupAttributes")
 	protected ConnectionGroupAttributeManager connectionGroupAttributeManager;
 
 	/**
 	 * Diagram attribute manager.
 	 */
 	@XStreamAlias("diagramAttributes")
 	protected DiagramAttributeManager diagramAttributeManager;
 
 	/**
 	 * Caching factory of visual elements.
 	 */
 	@XStreamAlias("connections")
 	protected final VisualModelCachingFactory visualModelFactory;
 
 	/**
 	 * Whether firing events should be suppressed.
 	 */
 	private boolean suppressEvents;
 
 	/**
 	 * Constructs new diagram from model.
 	 *
 	 * @param model
 	 *            base model
 	 */
 	public Diagram(Collection<IDataSet> model) {
 		this(model, new NullProgressMonitor());
 	}
 
 	/**
 	 * Constructs new diagram from model. Reports progress using a progress monitor.
 	 *
 	 * @param model
 	 *            base model
 	 * @param monitor
 	 *            non-null progress monitor
 	 * @throws IllegalArgumentException
 	 *             if progress monitor is null
 	 */
 	public Diagram(Collection<IDataSet> model, IProgressMonitor monitor) {
 		this(model, monitor, false);
 	}
 
 	/**
 	 * Constructs new diagram from model. Reports progress using a progress monitor.
 	 *
 	 * @param model
 	 *            base model
 	 * @param monitor
 	 *            non-null progress monitor
 	 * @param enhancable
 	 *            whether this Diagram may be enhanced (see {@link IDiagram#isEnhancable()})
 	 * @throws IllegalArgumentException
 	 *             if progress monitor is null
 	 */
 	public Diagram(Collection<IDataSet> model, IProgressMonitor monitor, boolean enhancable) {
 		super();
 
 		this.enhancable = enhancable;
 		settings = new DiagramSettings();
 		settings.addPropertyChangeListener(this);
 		settings.setEditorId(DUMMY_ID);
 
 		nodeAttributeManager = new NodeAttributeManager(model);
 		connectionGroupAttributeManager = new ConnectionGroupAttributeManager();
 		diagramAttributeManager = new DiagramAttributeManager();
 		visualModelFactory = new VisualModelCachingFactory(nodeAttributeManager, connectionGroupAttributeManager);
 
 		bindToAttributeManager();
 
 		monitor.beginTask(Messages.Diagram_0, 2 * countConnections(model));
 		createConnections(model, monitor);
 		createConnectionGroups(monitor);
 	}
 
 	private int countConnections(Collection<IDataSet> model) {
 		int ret = 0;
 		for (IDataSet dataSet : model) {
 			ret += dataSet.getRelations().size();
 		}
 		return ret;
 	}
 
 	@Override
 	protected Object readResolve() {
 		super.readResolve();
 		if (nodeAttributeManager == null) {
 			nodeAttributeManager = new NodeAttributeManager();
 		}
 		if (connectionGroupAttributeManager == null) {
 			connectionGroupAttributeManager = new ConnectionGroupAttributeManager();
 		}
 		if (diagramAttributeManager == null) {
 			diagramAttributeManager = new DiagramAttributeManager();
 		}
 		settings.addPropertyChangeListener(this);
 		visualModelFactory.setupConnectionGroups();
 		return this;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		return settings.getDisplayName();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getFile()
 	 */
 	public IFile getFile() {
 		return file;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#setFile(org.eclipse.core.resources.IFile)
 	 */
 	public void setFile(IFile file) {
 		IFile oldFile = this.file;
 		this.file = file;
 		firePropertyChange(FILE, oldFile, file);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#setDisplayName(java.lang.String)
 	 */
 	public void setDisplayName(String displayName) {
 		String oldDispName = settings.getDisplayName();
 		settings.setDisplayName(displayName);
 		firePropertyChange(NAME, oldDispName, displayName);
 		try {
 			if (file != null) {
 				file.touch(null);
 			}
 		} catch (CoreException e) {
 			Activator.getLogger().error("error touching file", e); //$NON-NLS-1$
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getDisplayName()
 	 */
 	public String getDisplayName() {
 		return settings.getDisplayName();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getStatistics()
 	 */
 	public List<Statistic> getStatistics() {
 		return getStatistics(new NullProgressMonitor());
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getStatistics(org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public List<Statistic> getStatistics(IProgressMonitor monitor) {
 		return new DefaultStatisticsProvider().statistics(this, monitor);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getSettings()
 	 */
 	public IDiagramSettings getSettings() {
 		return settings;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#setSettings(pl.edu.agh.cast.model.visual.backward.IDiagramSettings)
 	 */
 	public void setSettings(IDiagramSettings settings) {
 		this.settings = settings;
 	}
 
 	/**
 	 * Populates the set of connections based on the provided relations in base model.
 	 *
 	 * @param model
 	 *            model to populate with
 	 * @param monitor
 	 *            non-null progress monitor
 	 */
 	private void createConnections(Collection<IDataSet> model, IProgressMonitor monitor) {
 		monitor.subTask(Messages.Diagram_1);
 		for (IDataSet dataset : model) {
 			Set<String> currentDS = new HashSet<String>();
 			for (IRelation relation : dataset.getRelations()) {
 				// create connection and any required nodes
 				visualModelFactory.createConnection(relation, currentDS);
 				monitor.worked(1);
 			}
 		}
 	}
 
 	/**
 	 * Creates connections for given connection groups.
 	 *
 	 * @param monitor
 	 *            non-null progress monitor
 	 */
 	private void createConnectionGroups(IProgressMonitor monitor) {
 		monitor.subTask(Messages.Diagram_2);
 		for (Connection connection : visualModelFactory.getConnections()) {
 			ConnectionGroup cg = visualModelFactory.createConnectionGroup(connection);
 			cg.addConnection(connection);
 			monitor.worked(1);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#addNode(pl.edu.agh.cast.model.visual.backward.Node)
 	 */
 	public Node addNode(Node node) {
 		Node addedNode = addNodeInternal(node);
 		addConnectionsForNode(node);
 		firePropertyChange(CHILD, null, addedNode);
 		return addedNode;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#addNodes(java.util.Collection)
 	 */
 	public Collection<Node> addNodes(Collection<Node> nodes) {
 		Collection<Node> addedNodes = new LinkedList<Node>();
 		for (Node node : nodes) {
 			Node addedNode = addNodeInternal(node);
 			// addedNode must be equal to node, but if addedNode is another
 			// object, that means it was actually added as a new node to the
 			// diagram
 			if (addedNode != node) {
 				addedNodes.add(addedNode);
 			}
 		}
 		// add connections from all provided nodes
 		for (Node node : nodes) {
 			addConnectionsForNode(node);
 		}
 		firePropertyChange(CHILDREN, null, addedNodes);
 		return addedNodes;
 	}
 
 	/**
 	 * Adds a node to the model.
 	 *
 	 * @param node
 	 *            node to add
 	 */
 	protected Node addNodeInternal(Node node) {
 		// ignore nodes that are already present in the diagram (i.e. were
 		// created by diagram's model element factory)
 		if (!visualModelFactory.wasCreatedHere(node)) {
 			return visualModelFactory.copyNode(node);
 		} else {
 			return node;
 		}
 	}
 
 	/**
 	 * Adds connections of a given node to the diagram.
 	 *
 	 * @param node
 	 *            the node
 	 */
 	protected void addConnectionsForNode(Node node) {
 		for (ConnectionGroup cg : node.getConnectionGroups()) {
 			boolean first = true;
 			for (Connection c : cg.getAllConnections()) {
 				// ignore existing connections
 				if (visualModelFactory.wasCreatedHere(c)) {
 					continue;
 				}
 
 				// ignore connections between nodes that don't exist in
 				// current diagram
 				if (!visualModelFactory.wasCreatedHere(c.getSourceNode())
 				        || !visualModelFactory.wasCreatedHere(c.getTargetNode())) {
 					continue;
 				}
 
 				Connection newConn = visualModelFactory.copyConnection(c);
 				if (first) {
 					ConnectionGroup newGroup = visualModelFactory.copyConnectionGroup(cg, newConn);
 					newGroup.addConnection(newConn);
 					first = false;
 				} else {
 					visualModelFactory.createConnectionGroup(newConn).addConnection(newConn);
 				}
 			}
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#addConnection(pl.edu.agh.cast.model.visual.backward.Connection)
 	 */
 	public Connection addConnection(Connection c) {
 		// ignore connections that are already present in the diagram
 		// (i.e. were created by diagram's model element factory)
 		Connection connection = c;
 		if (!visualModelFactory.wasCreatedHere(c)) {
 			connection = visualModelFactory.copyConnection(c);
 		}
 		ConnectionGroup cg = visualModelFactory.createConnectionGroup(connection);
 		cg.addConnection(connection);
 
 		firePropertyChange(CONNECTION, null, connection);
 		return connection;
 
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#addConnections(java.util.Collection)
 	 */
 	public void addConnections(Collection<Connection> connections) {
 		for (Connection c : connections) {
 			addConnection(c);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#removeNode(pl.edu.agh.cast.model.visual.backward.Node)
 	 */
 	public void removeNode(Node node) {
 		if (!visualModelFactory.wasCreatedHere(node)) {
 			throw new IllegalArgumentException(NLS.bind("node {0} is not a child of this model", node)); //$NON-NLS-1$
 		}
 		visualModelFactory.removeNode(node);
 
 		/*
 		 * removeConnection can modify connection groups (when the group has no more connections, it is removed). We
 		 * need to first calculate which connections to remove and then remove them all at once. Otherwise a
 		 * ConcurrentModificationException is bound to occur.
 		 */
 		List<Connection> toRemove = new LinkedList<Connection>();
 		for (ConnectionGroup cg : node.getConnectionGroups()) {
 			if (!visualModelFactory.wasCreatedHere(cg)) {
 				continue;
 			}
 
 			for (Connection c : cg.getAllConnections()) {
 				if (!visualModelFactory.wasCreatedHere(c)) {
 					continue;
 				}
 
 				toRemove.add(c);
 			}
 		}
 		for (Connection c : toRemove) {
 			visualModelFactory.removeConnection(c);
 		}
 		firePropertyChange(CHILD, node, null);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#removeNodes(java.util.Collection)
 	 */
 	public void removeNodes(Collection<Node> nodes) {
 		for (Node node : nodes) {
 			removeNode(node);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#removeConnection(pl.edu.agh.cast.model.visual.backward.Connection)
 	 */
 	public void removeConnection(Connection connection) {
 		if (!visualModelFactory.wasCreatedHere(connection)) {
 			throw new IllegalArgumentException("connection is not a child of this model"); //$NON-NLS-1$
 		}
 		visualModelFactory.removeConnection(connection);
 		firePropertyChange(CONNECTION, connection, null);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getNodeAttributeManager()
 	 */
 	public NodeAttributeManager getNodeAttributeManager() {
 		return nodeAttributeManager;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getNodes()
 	 */
 	public Collection<Node> getNodes() {
 		return Collections.unmodifiableCollection(visualModelFactory.getNodes());
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getConnections()
 	 */
 	public Collection<Connection> getConnections() {
 		return Collections.unmodifiableCollection(visualModelFactory.getConnections());
 	}
 
 	/**
 	 * Returns caching factory of visual elements.
 	 *
 	 * @return caching factory of visual elements
 	 */
 	protected final VisualModelCachingFactory getVisualModelFactory() {
 		return visualModelFactory;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#findNode(java.lang.String)
 	 */
 	public Node findNode(String nodeId) {
 		// we could iterate getNodes(), but the factory can
 		// do it faster
 		return visualModelFactory.findNode(nodeId);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#findConnection(java.lang.String, java.lang.String, java.util.Date)
 	 */
 	public Connection findConnection(String sourceNodeId, String targetNodeId, Date date) {
 		return visualModelFactory.findConnection(sourceNodeId, targetNodeId, date);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#addAttributesFromEntities(java.util.Collection, java.util.Collection,
 	 *      java.util.Map, java.lang.String, org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public void addAttributesFromEntities(Collection<IEntity> entities, Collection<String> attributes,
 	        Map<String, AttributeMergePolicy> mergePolicies, String nodeType, IProgressMonitor monitor) {
 		// the key for the ID attribute of IEntity may differ from NodeAttributeManager.PERMANENT_ID
 		// as it is used via reflection mechanism to access AbstractMappable.getId() method.
 		String entityIdKey = "Id"; //$NON-NLS-1$
 		addAttributesFromEntities(entities, attributes, mergePolicies, nodeType, entityIdKey,
 		        NodeAttributeManager.PERMANENT_ID, monitor);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#addAttributesFromEntities(java.util.Collection, java.util.Collection,
 	 *      java.util.Map, java.lang.String, java.lang.String, java.lang.String,
 	 *      org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public void addAttributesFromEntities(Collection<IEntity> entities, Collection<String> attributes,
 	        Map<String, AttributeMergePolicy> mergePolicies, String nodeType, String sourceJoinAttribute,
 	        String targetJoinAttribute, IProgressMonitor monitor) {
 
 		// TODO if nodes have an attribute with the same name as entity, but
 		// different ValueType then this is not handled correctly
 
 		IProgressMonitor monit = monitor;
 
 		if (monit == null) {
 			monit = new NullProgressMonitor();
 		}
 		monit.beginTask(NLS.bind(Messages.DiagramEnhancingMonitor_1, getDisplayName()), entities.size()
 		        + visualModelFactory.getNodeCount());
 
 		monit.subTask(Messages.DiagramEnhancingMonitor_2);
 		NodeIndexer nodeIndexer = new NodeIndexer(visualModelFactory, targetJoinAttribute, nodeType, monit);
 
 		monit.subTask(Messages.DiagramEnhancingMonitor_3);
 
 		List<String> addedAttributes = new LinkedList<String>();
 
 		String[] attributeNames = null;
 		if (attributes != null) {
 			attributeNames = attributes.toArray(new String[attributes.size()]);
 		}
 
 		for (IEntity entity : entities) {
 
 			// get nodes that should be enhanced
 			Object joinValue = entity.getAttribute(sourceJoinAttribute);
 			List<Node> joinedNodes = nodeIndexer.lookup(joinValue);
 
 			// if no attribute list was provided or it was empty
 			// then add all entity attributes
 			if (attributes == null || attributeNames == null || attributeNames.length == 0) {
 				attributeNames = entity.getAttributeNames();
 			}
 
 			if (joinedNodes != null && joinedNodes.size() > 0) {
 				for (Node node : joinedNodes) {
 					for (String attrName : attributeNames) {
 
 						Object entValue = entity.getAttribute(attrName);
 
 						// TODO probably should be moved out of the nested loop when
 						// each type of node will have its own AttributeManager
 						// check if attribute is new for the node
 						if (!addedAttributes.contains(attrName)) {
 							if (!node.getAttributeManager().isRegisteredId(attrName)) {
 
 								// remember that this attribute has been added
 								addedAttributes.add(attrName);
 
 								// determine the type of the value
 								ValueType valType = null;
 								if (entValue != null) {
 									valType = ValueType.fromValue(entValue);
 								}
 								if (valType == null) {
 									valType = ValueType.String;
 								}
 
 								// register new attribute
 								node.getAttributeManager().registerAttribute(attrName, valType);
 							}
 						}
 
 						// retrieve the attribute instance
 						Attribute attribute = node.getAttributeManager().getAttribute(attrName);
 
 						// display all modified attributes
 						attribute.setShowAsLabel(attribute.isEditable());
 
 						if (attribute.getType() == ValueType.String) {
 							entValue = entValue == null ? null : entValue.toString();
 						}
 
 						if (addedAttributes.contains(attrName)) {
 							// if the attribute was newly added then don't bother with policies
 							node.setAttributeValue(attrName, entValue);
 						} else if (attribute.isEditable()) {
 							// if the attribute was already present then use policy to pick new value
 							AttributeMergePolicy policy = getMergePolicy(attrName, mergePolicies);
 							AttributeValue nodeValue = node.getAttributeValue(attrName);
 							Object oldValue = nodeValue == null ? null : nodeValue.getValue();
 							Object newValue = policy.mergeValues(attribute, oldValue, entValue);
 							node.setAttributeValue(attrName, newValue);
 						}
 
 					}
 				}
 			}
 			monit.worked(1);
 		}
 		monit.done();
 	}
 
 	private AttributeMergePolicy getMergePolicy(String attribute, Map<String, AttributeMergePolicy> mergePolicies) {
 		if (mergePolicies != null) {
 			AttributeMergePolicy policy = mergePolicies.get(attribute);
 			if (policy == null) {
 				policy = mergePolicies.get(null);
 			}
 			if (policy != null) {
 				return policy;
 			}
 		}
 		return AttributeMergePolicy.MERGE_POLICY_ALWAYS_SECOND;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.ModelElement#propertyChange(java.beans.PropertyChangeEvent)
 	 */
 	@Override
 	public void propertyChange(PropertyChangeEvent evt) {
 		if (DiagramSettings.LEGEND_SHOWN.equals(evt.getPropertyName())) {
 			// forward DiagramSettings events as own
 			firePropertyChange(evt.getPropertyName(), evt.getOldValue(), evt.getNewValue());
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#deselect()
 	 */
 	public void deselect() {
 		firePropertyChange(DESELECT, false, true);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#getDomainModel()
 	 */
 	public IDataSet getDomainModel() {
 		IDataSet data = new DataSet(getDisplayName());
 		for (IRelation relation : visualModelFactory.getRelations()) {
 			data.addRelation(relation);
 		}
 		return data;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#findRelation(pl.edu.agh.cast.model.visual.backward.Connection)
 	 */
 	public IRelation findRelation(Connection conn) {
 		return visualModelFactory.findRelation(conn);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.ModelElement#getAttributeManager()
 	 */
 	@Override
 	public AttributeManager getAttributeManager() {
 		return diagramAttributeManager;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IDiagram#isEnhancable()
 	 */
 	public boolean isEnhancable() {
 		return enhancable;
 	}
 
 	/**
 	 * Suppresses all events fired by this diagram.
 	 *
 	 * @param newSuppressEvents
 	 *            new value of suppression flag
 	 */
 	public void setSuppressEvents(boolean newSuppressEvents) {
 		suppressEvents = newSuppressEvents;
 		if (!newSuppressEvents) {
 			// fire dummy events, so that correct refreshing can take place
 			firePropertyChange(CHILDREN, null, null);
 			firePropertyChange(CONNECTION, null, null);
 		}
 	}
 
 	private boolean isSuppressEvents() {
 		return suppressEvents;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.ModelElement#firePropertyChange(java.lang.String, java.lang.Object,
 	 *      java.lang.Object)
 	 */
 	@Override
 	protected void firePropertyChange(String property, Object oldValue, Object newValue) {
 		if (!isSuppressEvents()) {
 			super.firePropertyChange(property, oldValue, newValue);
 		}
 	}
 
 }