ShapeCompartmentEditPart.java

/******************************************************************************
 * Copyright (c) 2002, 2009 IBM Corporation and others.
 * 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:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.runtime.diagram.ui.editparts;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.draw2d.Bendpoint;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.FigureCanvas;
import org.eclipse.draw2d.FigureListener;
import org.eclipse.draw2d.FreeformLayout;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LayoutAnimator;
import org.eclipse.draw2d.LayoutManager;
import org.eclipse.draw2d.RangeModel;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.gef.ConnectionEditPart;
import org.eclipse.gef.DragTracker;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartListener;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.EditPolicy;
import org.eclipse.gef.Request;
import org.eclipse.gef.editpolicies.SnapFeedbackPolicy;
import org.eclipse.gef.requests.SelectionRequest;
import org.eclipse.gef.tools.DeselectAllTracker;
import org.eclipse.gmf.runtime.common.ui.util.DisplayUtils;
import org.eclipse.gmf.runtime.diagram.core.listener.NotificationUtil;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.ContainerEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.ContainerNodeEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.CreationEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.PopupBarEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.ShapeCompartmentDropEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.XYLayoutEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.figures.ShapeCompartmentFigure;
import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ISurfaceEditPart;
import org.eclipse.gmf.runtime.diagram.ui.internal.editpolicies.DiagramLinkDragDropEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.internal.tools.RubberbandDragTracker;
import org.eclipse.gmf.runtime.diagram.ui.layout.FreeFormLayoutEx;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;

/**
 * A generic (sub) shape container that holds instances of
 * <code>ShapeNodeEditPart</code>s and manages the display of
 * <code>ConnectionNodeEditPart</code>s anchored to these shape editpart
 * instances.
 * 
 * @author mhanner
 */
public abstract class ShapeCompartmentEditPart
	extends ResizableCompartmentEditPart
	implements ISurfaceEditPart, PropertyChangeListener {

	/** private connection refresh manager. */
	private ConnectionRefreshMgr _crMgr;

	private boolean _refreshQueued = false;

	private boolean isSupportingViewActions = false;
    
    // Listen to editparts being added to or removed from this compartment
    // editpart so that when a figure moves within the compartment we can call
    // refreshConnections(). See bugzilla#146581.
    private EditPartListener editpartListener = new EditPartListener.Stub() {

        private FigureListener childFigureListener = new FigureListener() {

            public void figureMoved(IFigure source) {
                refreshConnections();
            }
        };

        public void childAdded(EditPart child, int index) {
            ((GraphicalEditPart) child).getFigure().addFigureListener(
                childFigureListener);
        }

        public void removingChild(EditPart child, int index) {
            ((GraphicalEditPart) child).getFigure().removeFigureListener(
                childFigureListener);

        }

    };

	/**
	 * Class used to refresh the connections associated to the shape
	 * compartment's children. This implementation will hide all connections
	 * whose endpoints are not visible inside the shape compartment.
	 */
	public static class ConnectionRefreshMgr {
		/**
		 * Cycles through all the connections associated to the editparts
		 * contained within the passed shape compartment and sets their
		 * visibility.
		 * 
		 * @see ConnectionNodeEditPart#getSourceConnectionAnchor()
		 * @see ConnectionNodeEditPart#getTargetConnectionAnchor()
		 * @param scep
		 *            edit part to consider
		 */
		protected void refreshConnections(ShapeCompartmentEditPart scep) {
			Iterator connectionNodes = getConnectionNodes(scep).iterator();
			while (connectionNodes.hasNext()) {
				ConnectionNodeEditPart cep = (ConnectionNodeEditPart) connectionNodes
					.next();
				Connection connection = (Connection) cep.getFigure();
				View connectionView = cep.getNotationView();
				if (connectionView != null && !connectionView.isVisible()) {
					/*
					 * Compartment is not responsible for refreshing a
					 * connection, the view of which is not visible
					 */
					continue;
				}
				
				IGraphicalEditPart source = (IGraphicalEditPart) getSourceEditPart(cep);
				IGraphicalEditPart target = (IGraphicalEditPart) getTargetEditPart(cep);
				if (source == null || target == null) {
					connection.setVisible(false);
					continue;
				}
				
				if (!source.getFigure().isShowing() || !target.getFigure().isShowing()) {
					connection.setVisible(false);
					continue;
				}
				
				ShapeCompartmentEditPart sContainer = getOwningShapeCompartment(source);
				ShapeCompartmentEditPart tContainer = getOwningShapeCompartment(target);
				// only deal with items contained within a shape compartment
				if (sContainer == null && tContainer == null) {
					continue;
				}
				boolean sfVisible = source != null;
				boolean tfVisible = target != null;
                
                ConnectionAnchor sc = cep.getSourceConnectionAnchor();
                ConnectionAnchor tc = cep.getTargetConnectionAnchor();
                Point sRefPoint;
                Point tRefPoint;
                List bendpoints = (List) connection.getConnectionRouter()
                    .getConstraint(connection);
                if (bendpoints != null && bendpoints.size() >= 2) {
                    sRefPoint = ((Bendpoint) bendpoints.get(0)).getLocation()
                        .getCopy();
                    connection.translateToAbsolute(sRefPoint);
                    tRefPoint = ((Bendpoint) bendpoints
                        .get(bendpoints.size() - 1)).getLocation().getCopy();
                    connection.translateToAbsolute(tRefPoint);
                } else {
                    sRefPoint = tc.getReferencePoint();
                    tRefPoint = sc.getReferencePoint();
                }
                Point sLoc = sc.getLocation(sRefPoint);
                Point tLoc = tc.getLocation(tRefPoint);
               
				Diagram diagram = ((View) scep.getModel()).getDiagram();
				Map registry = scep.getViewer().getEditPartRegistry();
				IGraphicalEditPart dep = (IGraphicalEditPart) registry
					.get(diagram);
				IFigure stopFigure = dep == null ? null
					: dep.getContentPane();
                boolean noSource = false;
                boolean noTarget = false;

				//
				// if sContainer is null, then the source connection is a child
				// of the diagram and not
				// a shape compartment. It's visibility is, therefore, true.
				if (sContainer != null) {
					ShapeCompartmentFigure fig = sContainer
						.getShapeCompartmentFigure();
                    noSource  = !fig.isVisible();
					sfVisible = isFigureVisible(fig, sLoc, stopFigure);
					if (!sfVisible) {
						sfVisible = isBorderItem(sContainer, source);
					}
				}
				//
				// if tContainer is null, then the source connection is a child
				// of the diagram and not
				// a shape compartment. It's visibility is, therefore, true.
				if (tContainer != null) {
					ShapeCompartmentFigure fig = tContainer
						.getShapeCompartmentFigure();
                    noTarget = !fig.isVisible();
                    tfVisible = isFigureVisible(fig, tLoc, stopFigure);
					if (!tfVisible) {
						tfVisible = isBorderItem(tContainer, target);
					}
				}
				// set connection visibility true iff both anchor points are
                // visible
                if (noSource || noTarget){
                  if (noSource && cep.getTarget()!=null)
                      cep.getTarget().refresh();
                  if (noTarget && cep.getSource()!=null)
                        cep.getSource().refresh();
                }else{
                    connection.setVisible(sfVisible && tfVisible);
                    refreshConnectionEnds(cep);
                }
			}
		}
        
        private void refreshConnectionEnds(ConnectionEditPart cEP){
            EditPart srcEditPart = cEP.getSource();
            EditPart trgEditPart = cEP.getTarget();
            Object model = cEP.getModel();
            if (model instanceof Edge){
                Edge edge = (Edge)model;
                View source = edge.getSource();
                View target = edge.getTarget();
                if (srcEditPart==null){
                    refreshEditPart(cEP.getViewer(), source);
                }
                if (trgEditPart==null){
                    refreshEditPart(cEP.getViewer(), target);
                }
            }
        }

        private void refreshEditPart(EditPartViewer  viewer, View view) {
            EditPart ep = (EditPart)viewer.getEditPartRegistry().get(view);
            if (ep!=null){
                ep.refresh();
            }
        }

		/**
		 * Return the set of {@link ConnectionNodeEditPart}s contained in the
		 * supplied shape compartment.
		 * 
		 * @param scep
		 *            a shape compartment.
		 * @return a {@link Set} of {@link ConnectionNodeEditPart}.
		 */

		protected Set getConnectionNodes(ShapeCompartmentEditPart scep) {
			Set endPoints = new HashSet();
			Object modelObject = scep.getModel();
			if (scep.getViewer() == null || modelObject == null 
				|| !(modelObject instanceof View)) {
				return endPoints;
			}
			
			if (((View)modelObject).getDiagram()==null)
				return endPoints;

			Diagram diagram = ((View) modelObject).getDiagram();
			Map registry = scep.getViewer().getEditPartRegistry();
			List edges = diagram.getEdges();
			Iterator edgesIterator = edges.iterator();

			while (edgesIterator.hasNext()) {
				Edge edge = (Edge) edgesIterator.next();
				EditPart endPoint = (EditPart) registry.get(edge.getSource());
				if (isChildOf(scep, endPoint)) {
					Object cep = registry.get(edge);
					if (cep != null) {
						endPoints.add(cep);
					}
					continue;
				}
				endPoint = (EditPart) registry.get(edge.getTarget());
				if (isChildOf(scep, endPoint)) {
					Object cep = registry.get(edge);
					if (cep != null) {
						endPoints.add(cep);
					}
				}
			}
			return endPoints;
		}

		/**
		 * Return <tt>true</tt> if <tt>parent</tt> child's ancestor;
		 * otherwise <tt>false</tt>
		 * 
		 * @param parent
		 *            parent to consider
		 * @param child
		 *            child to consider
		 * @return <tt>true</tt> or <tt>false</tt>
		 */
		protected boolean isChildOf(EditPart parent, EditPart child) {
			EditPart walker = child;
			while (walker != null && walker != parent) {
				walker = walker.getParent();
			}
			return walker != null;
		}

		/**
		 * gets the supplied editparts containing shape compartment.
		 * 
		 * @param ep
		 *            edit part
		 * @return <code> ShapeCompartmentEditPart</code>
		 */
		protected ShapeCompartmentEditPart getOwningShapeCompartment(EditPart ep) {
			EditPart walker = ep;
			while (walker != null
				&& !(walker instanceof ShapeCompartmentEditPart)) {
				walker = walker.getParent();
			}
			return (ShapeCompartmentEditPart) walker;
		}

		/**
         * This method can be overridden to allow connections between border
         * items around the container of the compartment to be drawn to items
         * within the interior of the compartment. This method should not return
         * true for all border items, only for those may be outside of the area
         * within the shape compartment.
         * 
         * @param scep
         * @param itemEditPart
         * @return true if the itemEditPart is a border item around or outside
         *         the shape compartment editpart passed in; false otherwise.
         */
        protected boolean isBorderItem(ShapeCompartmentEditPart scep,
                IGraphicalEditPart itemEditPart) {
            return false;
        }

		/**
		 * Returns source edit part.
		 * 
		 * @param connectionEditPart
		 * @return EditPart
		 */
		protected EditPart getSourceEditPart(
				ConnectionEditPart connectionEditPart) {
			return connectionEditPart.getSource();
		}

		/**
		 * Returns target editPart
		 * 
		 * @param connectionEditPart
		 * @return EditPart
		 */
		protected EditPart getTargetEditPart(
				ConnectionEditPart connectionEditPart) {
			return connectionEditPart.getTarget();
		}

		/**
		 * gets the source connections of the passed edit part
		 * 
		 * @param editPart
		 *            edit part to consider
		 * @return source connections
		 */
		protected List getSourceConnections(IGraphicalEditPart editPart) {
			return editPart.getSourceConnections();
		}

		/**
		 * get the target connections of the passed edit part
		 * 
		 * @param editPart
		 *            edit part to consider
		 * @return target connection
		 */
		protected List getTargetConnections(IGraphicalEditPart editPart) {
			return editPart.getTargetConnections();
		}

		/**
		 * Walks up the hierarchy to make sure that supplied figure is visible
		 * inside its figure hierarchy. <BR>
		 * Same as calling <code>isFigureVisible(figure, loc, null);</code>
		 * 
		 * @param figure
		 *            The figure under test.
		 * @param loc
		 *            the child's location in absolute coordinates.
		 * @return boolean visibility of the figure by going up the chain.
		 */
		protected boolean isFigureVisible(final IFigure figure, final Point loc) {
			return isFigureVisible(figure, loc, null);
		}

		/**
		 * Walks up the hierarchy to make sure that the point <code>loc</code> is visible
		 * inside its figure hierarchy. <BR>
		 * 
		 * @param figure
		 *            The figure under test.
		 * @param loc
		 *            the child's location in absolute coordinates.
		 * @param stopFigure
		 *            root figure in the figure hierarchy being tested.
		 * @return boolean visibility of the figure by going up the chain.
		 */
		protected boolean isFigureVisible(final IFigure figure,
				final Point loc, final IFigure stopFigure) {
			if (!(figure.isShowing())) {
				return false;
			} else {
				Rectangle bounds = figure.getBounds().getCopy();
				figure.translateToAbsolute(bounds);
				if (!(bounds.contains(loc))) {
					return false;
				}
			}

			IFigure parent = figure.getParent();
			while (parent != null && parent != stopFigure) {
				return isFigureVisible(parent, loc, stopFigure);
			}
			return true;
		}
	}

	/**
	 * Constructor for ShapeCompartmentEditPart.
	 * 
	 * @param view
	 *            the view <code>controlled</code> by this editpart.
	 */
	public ShapeCompartmentEditPart(View view) {
		super(view);
	}

	/**
	 * Returns the connection refresh manager.
	 * 
	 * @return <code>ConnectionRefreshMgr</code>
	 */
	protected final ConnectionRefreshMgr getConnectionRefreshMgr() {
		if (_crMgr == null) {
			_crMgr = createConnectionRefreshMgr();
		}
		return _crMgr;
	}

	/**
	 * Factory method to create a refresh connection. This implementation
	 * returns a {@link ShapeCompartmentEditPart.ConnectionRefreshMgr} instance.
	 * 
	 * @return <code>ConnectionRefreshMgr</code>
	 */
	protected ConnectionRefreshMgr createConnectionRefreshMgr() {
		return new ConnectionRefreshMgr();
	}

	/**
	 * Returns the layout manager to be used by this shape compartment. This
	 * implemantion returns a {@link FreeformLayout} instance.
	 * 
	 * @return a layout manager.
	 */
	protected LayoutManager getLayoutManager() {
		return new FreeFormLayoutEx();
	}

	/**
	 * Creates a scrollpane (with auto scrollbars) in which the children are
	 * drawn. The factory hint property is used to set this compartments label.
	 */
	protected IFigure createFigure() {
		ShapeCompartmentFigure scf = new ShapeCompartmentFigure(getCompartmentName(), getMapMode());
		scf.getContentPane().setLayoutManager(getLayoutManager());
        scf.getContentPane().addLayoutListener(LayoutAnimator.getDefault());

		return scf;
	}

	/**
	 * Convenience method to retrieve the shape compartment figure. Same as
	 * calling <code>(ShapeCompartmentFigure)getCompartmentFigure()</code>.
	 * 
	 * @return <code>ShapeCompartmentFigure</code>
	 */
	public ShapeCompartmentFigure getShapeCompartmentFigure() {
		return (ShapeCompartmentFigure) getCompartmentFigure();
	}

	/** Return the container in which shape editparts are added. */
	public IFigure getContentPane() {
		return getShapeCompartmentFigure().getContentPane();
	}

	/**
	 * Adds the following editpolicies: <BR>
	 * <UL>
	 * <LI> {@link EditPolicyRoles#CREATION_ROLE} :: {@link CreationEditPolicy}
	 * <LI> {@link EditPolicy#LAYOUT_ROLE} :: {@link XYLayoutEditPolicy}
	 * <LI> {@link EditPolicy#CONTAINER_ROLE} :: {@link ContainerEditPolicy}
	 * <LI> {@link EditPolicyRoles#DRAG_DROP_ROLE} ::
	 * {@link DiagramLinkDragDropEditPolicy}
	 * <LI> {@link EditPolicy#GRAPHICAL_NODE_ROLE} ::
	 * {@link ContainerNodeEditPolicy}
	 * 
	 * <LI> {@link EditPolicyRoles#SNAP_FEEDBACK_ROLE} ::
	 * {@link SnapFeedbackPolicy}
	 * <LI> {@link EditPolicyRoles#DRAG_DROP_ROLE} ::
	 * {@link ShapeCompartmentDropEditPolicy}
	 * <LI> {@link EditPolicyRoles#POPUPBAR_ROLE} :: {@link PopupBarEditPolicy}
	 * </UL>
	 */
	protected void createDefaultEditPolicies() {
		super.createDefaultEditPolicies();
		installEditPolicy(EditPolicyRoles.CREATION_ROLE,
			new CreationEditPolicy());
		installEditPolicy(EditPolicy.LAYOUT_ROLE, new XYLayoutEditPolicy());
		installEditPolicy(EditPolicy.CONTAINER_ROLE, new ContainerEditPolicy());
		// TODO: this edit policy get overriden by code at the end of this
		// function
		// may be this breaks some use cases; it needs to be checked
		installEditPolicy(EditPolicyRoles.DRAG_DROP_ROLE,
			new DiagramLinkDragDropEditPolicy());
		installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE,
			new ContainerNodeEditPolicy());
		// Install an edit policy for snap
		installEditPolicy(EditPolicyRoles.SNAP_FEEDBACK_ROLE,
			new SnapFeedbackPolicy());
		installEditPolicy(EditPolicyRoles.DRAG_DROP_ROLE,
			new ShapeCompartmentDropEditPolicy());
		installEditPolicy(EditPolicyRoles.POPUPBAR_ROLE,
			new PopupBarEditPolicy());
	}

	/**
	 * Handles property change callbacks. All unrecognized events are forwarded
	 * to the parent class.
	 * 
	 * @param event
	 *            a property change event.
	 */
	protected void handlePropertyChangeEvent(PropertyChangeEvent event) {
		String pName = event.getPropertyName();
		if (RangeModel.PROPERTY_EXTENT.equals(pName)
			|| RangeModel.PROPERTY_VALUE.equals(pName)) {
			refreshConnections();
		}
	}

	/**
	 * Refreshes the connections inside the shape compartment if the supplied
	 * event is for an element inserted or removed from the editpart.
	 * 
	 * @see #refreshConnections()
	 * @param event
	 *            a model server event.
	 */
	protected void handleNotificationEvent(Notification event) {
		Object feature = event.getFeature();
		if (NotationPackage.eINSTANCE.getSize_Width().equals(feature)
			|| NotationPackage.eINSTANCE.getSize_Height().equals(feature)) {
			refreshConnections();
		} else
			super.handleNotificationEvent(event);

		if (NotificationUtil.isElementAddedToSlot(event)
			|| NotificationUtil.isElementRemovedFromSlot(event)) {
			refreshConnections();
		}
	}

	/**
	 * Refresh the connections associated the the children of this shape
	 * compartment.
	 */
	protected void refreshConnections() {
		if (!_refreshQueued) {
			_refreshQueued = true;
			DisplayUtils.getDisplay().asyncExec(new Runnable() {
				public void run() {
					forceRefreshConnections();
				}
			});
		}
	}
    
    /**
     * Refresh the connections associated the the children of this shape
     * compartment.
     */
    protected void forceRefreshConnections() {
      try {
            //
            // test if active since the editpartg may have been
            // deleted
            // by the time this method is executed.
            if (ShapeCompartmentEditPart.this.isActive()) {
                getConnectionRefreshMgr().refreshConnections(
                    ShapeCompartmentEditPart.this);
            }
        } finally {
            ShapeCompartmentEditPart.this._refreshQueued = false;
        }
        
    }

	/** Unregisters this instance as a PropertyChangeListener on its figure. */
	protected void unregister() {
		super.unregister();
		getShapeCompartmentFigure().removePropertyChangeListener(this);
		EditPartViewer viewer = getViewer();
		if (viewer != null && viewer.getControl() instanceof FigureCanvas) {
			FigureCanvas figureCanvas = (FigureCanvas) viewer.getControl();
			figureCanvas.getViewport().getVerticalRangeModel()
				.removePropertyChangeListener(this);
			figureCanvas.getViewport().getHorizontalRangeModel()
				.removePropertyChangeListener(this);
		}
	}

	/** Registers this instance as a PropertyChangeListener on its figure. */
	protected void registerVisuals() {
		super.registerVisuals();
		getShapeCompartmentFigure().addPropertyChangeListener(this);

		EditPartViewer viewer = getViewer();
		if (viewer != null && viewer.getControl() instanceof FigureCanvas) {
			FigureCanvas figureCanvas = (FigureCanvas) viewer.getControl();
			figureCanvas.getViewport().getVerticalRangeModel()
				.addPropertyChangeListener(this);
			figureCanvas.getViewport().getHorizontalRangeModel()
				.addPropertyChangeListener(this);
		}
	}

	/**
	 * Determines if the shape compartment supports drag selection of it's
	 * children. Otherwise, it will default to the core behavior of selecting
	 * the compartment itself on click on the compartment background surface.
	 * 
	 * @return <code>boolean</code> <code>true</code> if shape compartment
	 *         supports drag selection of it's children, <code>false</code>
	 *         otherwise.
	 */
	protected boolean supportsDragSelection() {
		return true;
	}

	/**
	 * @see org.eclipse.gef.EditPart#getDragTracker(org.eclipse.gef.Request)
	 */
	public DragTracker getDragTracker(Request req) {
		if (!supportsDragSelection())
			return super.getDragTracker(req);

		if (req instanceof SelectionRequest
			&& ((SelectionRequest) req).getLastButtonPressed() == 3)
			return new DeselectAllTracker(this) {

				protected boolean handleButtonDown(int button) {
					getCurrentViewer().select(ShapeCompartmentEditPart.this);
					return true;
				}
			};
		return new RubberbandDragTracker() {

			protected void handleFinished() {
				if (getViewer().getSelectedEditParts().isEmpty())
					getViewer().select(ShapeCompartmentEditPart.this);
			}
		};
	}

	/** Also calls {@link #refreshConnections()}. */
	protected void refreshVisibility() {
		super.refreshVisibility();
        View view  = getNotationView();
        if (view !=null && !view.isVisible())
            forceRefreshConnections();
        else
            refreshConnections();
	}

	/*
	 * (non-Javadoc)
	 */
	public boolean isSupportingViewActions() {
		return this.isSupportingViewActions;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ISurfaceEditPart#setIsSupportingViewActions(boolean)
	 */
	public void setIsSupportingViewActions(boolean supportsViewActions) {
		this.isSupportingViewActions = supportsViewActions;
	}

	/**
	 * Handles the passed property changed event only if the editpart's view is
	 * not deleted.
	 */
	public final void propertyChange(PropertyChangeEvent event) {
		if (isActive())
			handlePropertyChangeEvent(event);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ISurfaceEditPart#getPrimaryEditParts()
	 */
	public List getPrimaryEditParts() {
		List connections = new ArrayList();

		Object diagramEditPart = getViewer().getEditPartRegistry().get(
			getDiagramView());

		List shapes = getChildren();
		Set connectableEditParts = new HashSet(shapes);
		Iterator iter = shapes.iterator();
		while (iter.hasNext()) {
			getBorderItemEditParts((EditPart) iter.next(), connectableEditParts);
		}

		if (diagramEditPart instanceof DiagramEditPart) {
			Iterator diagramConnections = ((DiagramEditPart) diagramEditPart)
				.getConnections().iterator();
			while (diagramConnections.hasNext()) {
				ConnectionEditPart connection = (ConnectionEditPart) diagramConnections
					.next();
				if (connectableEditParts.contains(connection.getSource())
					|| connectableEditParts.contains(connection.getTarget()))
					connections.add(connection);
			}
		}

		if (connections.size() > 0 || shapes.size() > 0) {
			List primaryEditParts = new ArrayList();
			primaryEditParts.addAll(shapes);
			primaryEditParts.addAll(connections);
			return primaryEditParts;
		}
		return Collections.EMPTY_LIST;
	}
	
	/**
	 * This method searches an edit part for a child that is a border item edit part
	 * @param parent part needed to search
	 * @param set to be modified of border item edit parts that are direct children of the parent
	 */
	private void getBorderItemEditParts(EditPart parent, Set retval) {
		
		Iterator iter = parent.getChildren().iterator();
		while(iter.hasNext()) {
			EditPart child = (EditPart)iter.next();
			if( child instanceof IBorderItemEditPart ) {
				retval.add(child);
				retval.addAll(child.getChildren());
			}
			getBorderItemEditParts(child, retval);
		}
	}
    
    public void addNotify() {
        addEditPartListener(editpartListener);
        super.addNotify();
    }

    public void removeNotify() {
        removeEditPartListener(editpartListener);
        super.removeNotify();
    }

	/* (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.ui.editparts.ResizableCompartmentEditPart#setCollapsed(boolean, boolean)
	 */
	protected void setCollapsed(boolean collapsed, boolean animate) {
		super.setCollapsed(collapsed, animate);
		refreshConnections();
	}

}