/******************************************************************************
 * 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.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.transaction.RunnableWithResult;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.gef.AccessibleEditPart;
import org.eclipse.gef.DragTracker;
import org.eclipse.gef.EditDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.EditPolicy;
import org.eclipse.gef.Request;
import org.eclipse.gef.RequestConstants;
import org.eclipse.gef.RootEditPart;
import org.eclipse.gef.SnapToHelper;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.commands.CompoundCommand;
import org.eclipse.gef.commands.UnexecutableCommand;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
import org.eclipse.gef.requests.CreateConnectionRequest;
import org.eclipse.gef.requests.DropRequest;
import org.eclipse.gef.requests.GroupRequest;
import org.eclipse.gef.requests.ReconnectRequest;
import org.eclipse.gef.requests.TargetRequest;
import org.eclipse.gmf.runtime.common.core.util.IAdaptableSelection;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.common.core.util.Trace;
import org.eclipse.gmf.runtime.common.ui.services.action.filter.ActionFilterService;
import org.eclipse.gmf.runtime.common.ui.services.parser.CommonParserHint;
import org.eclipse.gmf.runtime.diagram.core.listener.DiagramEventBroker;
import org.eclipse.gmf.runtime.diagram.core.listener.NotificationListener;
import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.CanonicalEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.DecorationEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.PropertyHandlerEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.SemanticEditPolicy;
import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIDebugOptions;
import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIPlugin;
import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIStatusCodes;
import org.eclipse.gmf.runtime.diagram.ui.internal.commands.ToggleCanonicalModeCommand;
import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.DummyEditPart;
import org.eclipse.gmf.runtime.diagram.ui.internal.ruler.SnapToHelperUtil;
import org.eclipse.gmf.runtime.diagram.ui.internal.services.editpolicy.EditPolicyService;
import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramColorRegistry;
import org.eclipse.gmf.runtime.diagram.ui.label.ILabelDelegate;
import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramGraphicalViewer;
import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramEditDomain;
import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer;
import org.eclipse.gmf.runtime.diagram.ui.preferences.IPreferenceConstants;
import org.eclipse.gmf.runtime.diagram.ui.requests.CreateConnectionViewRequest;
import org.eclipse.gmf.runtime.diagram.ui.requests.EditCommandRequestWrapper;
import org.eclipse.gmf.runtime.diagram.ui.tools.DragEditPartsTrackerEx;
import org.eclipse.gmf.runtime.diagram.ui.util.EditPartUtil;
import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities;
import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode;
import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;
import org.eclipse.gmf.runtime.emf.core.util.EMFCoreUtil;
import org.eclipse.gmf.runtime.gef.ui.internal.editpolicies.GraphicalEditPolicyEx;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.FillStyle;
import org.eclipse.gmf.runtime.notation.FontStyle;
import org.eclipse.gmf.runtime.notation.LineStyle;
import org.eclipse.gmf.runtime.notation.LineType;
import org.eclipse.gmf.runtime.notation.LineTypeStyle;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.NotationFactory;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.resource.DeviceResourceException;
import org.eclipse.jface.resource.FontDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.ui.IActionFilter;

/**
 * @author melaasar,mmostafa
 * 
 * The root of all component graphical edit parts that own a view as a model
 */
public abstract class GraphicalEditPart
    extends AbstractGraphicalEditPart
    implements IGraphicalEditPart, IAdaptableSelection, NotificationListener {
  
    /** A map of listener filters ids to filter data */
    private Map listenerFilters;
    
    /** Used for accessibility. */
    protected AccessibleEditPart accessibleEP;

    /** Used for registering and unregistering the edit part */
    protected String elementGuid;

    /**
     * Cache the editing domain after it is retrieved.
     */
    private TransactionalEditingDomain editingDomain;

    /**
     * Cache the font data when a font is created so that it can be
     * disposed later.
     */
    private FontData cachedFontData;
    
    /**
     * Flag to indicate if the edit part is in edit mode
     * @since 1.2
     */
    final protected static int FLAG__IS_EDITABLE = MAX_FLAG << 1;
    
    /**
     * Flag to indicate automatic updates of source/target connections visibility triggered by the change
     * of this editpart's visibility
     * @since 1.2
     */
    final protected static int FLAG__AUTO_CONNECTIONS_VISIBILITY = MAX_FLAG << 2;
    
    /**
     * The left-most bit that is reserved by this class for setting flags. Subclasses may
     * define additional flags starting at <code>(GRAPHICAL_EDIT_PART__MAX_FLAG << 1)</code>.
     * @since 1.2
     */
    final protected static int GRAPHICAL_EDIT_PART__MAX_FLAG = FLAG__AUTO_CONNECTIONS_VISIBILITY;
    
    /**
     * Create an instance.
     * 
     * @param model
     *            the underlying model.
     */
    public GraphicalEditPart(EObject model) {
        setModel(model);
        setFlag(FLAG__IS_EDITABLE, true);
        setFlag(FLAG__AUTO_CONNECTIONS_VISIBILITY, true);
    }
    
    /** Registers this editpart to recieve notation and semantic events. */
    public void activate() {
        if (isActive()) {
            return;
        }
        addNotationalListeners();

        EObject semanticElement;
        EObject semanticProxy;
        if (hasNotationView()) {
            semanticProxy = ((View) super.getModel()).getElement();
            if ((semanticProxy==null)||semanticProxy.eIsProxy()) {
                semanticElement = null;
            } else {
                semanticElement = semanticProxy;
            }
        } else {
            semanticProxy = (EObject) basicGetModel();
            if ((semanticProxy!=null) && semanticProxy.eIsProxy()) {
                semanticElement = EMFCoreUtil.resolve(getEditingDomain(),
                    semanticProxy);
            } else {
                semanticElement = semanticProxy;
            }
        }

        if (semanticElement != null)
            addSemanticListeners();
        else if (semanticProxy != null) {
            addListenerFilter("SemanticProxy", this, semanticProxy); //$NON-NLS-1$
        }
        GraphicalEditPart.super.activate();

    }

    /**
     * Adds a listener filter by adding the given listener to a passed notifier
     * 
     * @param filterId
     *            A unique filter id (within the same editpart instance)
     * @param listener
     *            A listener instance
     * @param element
     *            An element to add the listener to
     */
    protected void addListenerFilter(String filterId,
            NotificationListener listener,
            EObject element) {
        if (element == null)
            return;

        DiagramEventBroker diagramEventBroker = getDiagramEventBroker();
        if (diagramEventBroker != null) {
        	assert filterId != null;
        	assert listener != null;
            if (listenerFilters == null)
                listenerFilters = new HashMap();
            diagramEventBroker.addNotificationListener(element,listener);
            listenerFilters.put(filterId.intern(), new Object[] {element, listener});
        }
    }
    
    /**
     * Adds a listener filter by adding the given listener to a passed notifier
     * 
     * @param filterId
     *            A unique filter id (within the same editpart instance)
     * @param listener
     *            A listener instance
     * @param element
     *            An element to add the listener to
     */
    protected void addListenerFilter(String filterId,
            NotificationListener listener,
            EObject element,
            EStructuralFeature feature) {
        if (element == null)
            return;
                
        DiagramEventBroker diagramEventBroker = getDiagramEventBroker();
        if (diagramEventBroker != null) {
        	assert filterId != null;
        	assert listener != null;
            if (listenerFilters == null)
                listenerFilters = new HashMap();

            diagramEventBroker.addNotificationListener(element,feature,listener);

            listenerFilters.put(filterId.intern(), new Object[] {element,feature, listener});
        }
    }

    /** Creates a connection editpart. */
    final protected org.eclipse.gef.ConnectionEditPart createConnection(
            Object connectionView) {
        return (org.eclipse.gef.ConnectionEditPart) createChild(connectionView);
    }

    /**
     * Overridden to support editpolicies installed programmatically and via the
     * <code>EditPolicyService</code>. Subclasses should override
     * <code>createDefaultEditPolicies()</code>.
     * 
     * @see org.eclipse.gef.editparts.AbstractEditPart#createEditPolicies()
     */
    final protected void createEditPolicies() {
        createDefaultEditPolicies();
        EditPolicyService.getInstance().createEditPolicies(this);
    }

    /**
     * Should be overridden to install editpolicies programmatically.
     * 
     * @see org.eclipse.gef.editparts.AbstractEditPart#createEditPolicies()
     */
    protected void createDefaultEditPolicies() {
        installEditPolicy(EditPolicyRoles.SEMANTIC_ROLE,
            new SemanticEditPolicy());
        installEditPolicy(EditPolicyRoles.PROPERTY_HANDLER_ROLE,
            new PropertyHandlerEditPolicy());
        installEditPolicy(EditPolicyRoles.DECORATION_ROLE,
            new DecorationEditPolicy());
    }

    public void deactivate() {
        if ( !isActive() ) {
            return;
        }
        removeNotationalListeners();
        removeSemanticListeners();
        if (listenerFilters != null ) {
            for (Iterator i = listenerFilters.keySet().iterator(); i.hasNext();) {
                Object[] obj = (Object[]) listenerFilters.get(i.next());
                if (obj.length>2){
                    getDiagramEventBroker().
                        removeNotificationListener((EObject)obj[0],(EStructuralFeature) obj[1],(NotificationListener) obj[2]);
                }else {
                    getDiagramEventBroker().removeNotificationListener((EObject) obj[0],(NotificationListener) obj[1]);
                }
            }
        }
        super.deactivate();
    }

    public void removeNotify() {
        
        View view = getNotationView();
        if (view != null && !view.isVisible() && getFlag(FLAG__AUTO_CONNECTIONS_VISIBILITY)){
            setConnectionsVisibility(false);
        }
        
        super.removeNotify();
        
        if (cachedFontData != null) {
            getResourceManager().destroyFont(
                FontDescriptor.createFrom(cachedFontData));
            cachedFontData = null;
        }

    }

    /**
     * executes the passed <code>Command</code>
     * @param command the command to exectue
     */
    protected void executeCommand(Command command) {
        getViewer().getEditDomain().getCommandStack().execute(command);
    }
    
    /**
     * Access the model member variable
     * @return
     */
    final protected Object basicGetModel(){
        return super.getModel();
    }

    /** Adds the ability to adapt to the edit part's view class. */
    public Object getAdapter(Class key) {       

        // Adapt to IActionFilter
        if (key == IActionFilter.class) {
            return ActionFilterService.getInstance();
        }

        if (View.class.isAssignableFrom(key)) {
            Object _model = getModel();
            if (key.isInstance(_model))
                return _model;
            else
                return null;
        }

        if (key == SnapToHelper.class) {
            return SnapToHelperUtil.getSnapHelper(this);
        }

        Object model = basicGetModel();
        if (model != null &&
            EObject.class.isAssignableFrom(key)) {
            // Adapt to semantic element
            EObject semanticObject = null;
            if (hasNotationView()){
                semanticObject = ViewUtil.resolveSemanticElement((View)model);
            }
            else{
                EObject element = (EObject)model;
                if (element.eIsProxy()){
                    semanticObject = EMFCoreUtil.resolve(getEditingDomain(), element);
                }
            }
            if ((semanticObject!=null) && key.isInstance(semanticObject)) {
                return semanticObject;
            }
            else if (key.isInstance(model)){
                return model;
            }
            
        }

        // Delegate
        return super.getAdapter(key);
    }

    /**
     * Utility method to get the primary view and then query for a child based on the
     * semantic hint
     * 
     * @param semanticHint <code>String</code> that is the hint that can retrieved on the getType
     * method of <code>View</code>
     * @return <code>IGraphicalEditPart</code> that matches with the given semanticHint
     */
    public IGraphicalEditPart getChildBySemanticHintOnPrimaryView(String semanticHint) {
        View primaryView = getPrimaryView();
        View childView = ViewUtil.getChildBySemanticHint(primaryView, semanticHint);
        if (childView != null)
            return  (IGraphicalEditPart)getViewer().getEditPartRegistry().get(childView);

        return null;
    }
    
    /**
     * Method getChildBySemanticHint.
     * 
     * @param semanticHint
     * @return IGraphicalEditPart
     */
    public IGraphicalEditPart getChildBySemanticHint(String semanticHint) {
        View view;
        if (hasNotationView() && (view = (View) super.getModel()) != null) {
            view = ViewUtil.getChildBySemanticHint(view,semanticHint);
            if (view != null){
                IGraphicalEditPart ep =   (IGraphicalEditPart)getViewer().getEditPartRegistry().get(view);
                // TODO remove this code after the clients change there code to 
                // be aware of the on demand editpart creation
                if (ep == null){
                    // the ep had not been created yet, create a dummy one 
                    ep  =  new DummyEditPart(view);
                }
                return ep;
            }
        }
        return null;
    }
    
    /**
     * Method getChildViewBySemanticHint.
     * 
     * @param semanticHint
     * @return IGraphicalEditPart
     */
    public View getChildViewBySemanticHint(String semanticHint) {
        View view;
        if (hasNotationView() && (view = (View) super.getModel()) != null) {
            return ViewUtil.getChildBySemanticHint(view, semanticHint);
        }
        return null;
    }

    
    /** counter that tracs the recursive depth of the getCommand() method. */
    private static volatile int GETCOMMAND_RECURSIVE_COUNT = 0;
    
    /** A list of editparts who's canonical editpolicies are to be temporarily disabled. */
    private static Set _disableCanonicalEditPolicyList = new HashSet();
    

    /** Return a command for the supplied request. */
    public Command getCommand(Request _request) {
        if ( !isEditModeEnabled() ) {
            if (RequestConstants.REQ_OPEN.equals(_request.getType())) {
                //allowed, continue
            }
            else {
                return UnexecutableCommand.INSTANCE;
            }           
        }
        
        Command cmd = null;
        try {
            GETCOMMAND_RECURSIVE_COUNT++;
            final Request request = _request;
            try {
                cmd = (Command) getEditingDomain().runExclusive(
                    new RunnableWithResult.Impl() {

                        public void run() {
                            setResult(GraphicalEditPart.super
                                .getCommand(request));
                        }
                    });
            } catch (InterruptedException e) {
                Trace.catching(DiagramUIPlugin.getInstance(),
                    DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(),
                    "getCommand", e); //$NON-NLS-1$
                Log.error(DiagramUIPlugin.getInstance(),
                    DiagramUIStatusCodes.IGNORED_EXCEPTION_WARNING,
                    "getCommand", e); //$NON-NLS-1$
            }
            

            if ( cmd != null ) {
                _disableCanonicalEditPolicyList.addAll(disableCanonicalFor(_request));
            }
            
            GETCOMMAND_RECURSIVE_COUNT--;
            
            if ( GETCOMMAND_RECURSIVE_COUNT == 0 ) {
                if ( cmd != null 
                        && !_disableCanonicalEditPolicyList.isEmpty() ) {
                    CompoundCommand cc = new CompoundCommand();
                    cc.setLabel( cmd.getLabel() );
                    ToggleCanonicalModeCommand tcmd = 
                        ToggleCanonicalModeCommand.getToggleCanonicalModeCommand(_disableCanonicalEditPolicyList, false);
                    cc.add( tcmd );
                    cc.add( cmd );
                    ToggleCanonicalModeCommand tcmd2 = ToggleCanonicalModeCommand.getToggleCanonicalModeCommand(tcmd, true);
                    if (tcmd2 != null) {
                        tcmd2.setDomain(getEditingDomain());
                    }
                    cc.add( tcmd2 );
                    _disableCanonicalEditPolicyList.clear();
                    return cc.unwrap();
                }
            }
        }
        catch( RuntimeException t ) {
            GETCOMMAND_RECURSIVE_COUNT = 0;
            throw t;
        }
        return cmd;
        
    }
    
    /**
     * Return a list of editparts who's canonical editpolicies should be disabled
     * prior to executing the commands associated to the supplied request.
     * This implementation will return the editpart honoring a <code>SemanticWrapperRequest</code>
     * and a <code>CreateConnectionViewRequest</code>'s source and target editparts.
     *
     * @param request a request that has returned a command.
     * @return list of editparts.
     */
    protected Collection disableCanonicalFor( final Request request ) {
        //
        // not the most generic of solution; however, it will have to do for now...
        //
        // Alternate solutions
        // 1. common request interface on all the requests
        //  IRequest#getAffectedEditParts
        //
        // 2. Traverse down the command and collect of the ICommand#getAffectedObjects()
        //  -- this requires that all our commands properly set this value.
        
        Set hosts = new HashSet();
        if ( (request instanceof EditCommandRequestWrapper)  
                || request instanceof TargetRequest
                || request instanceof DropRequest ) {
            hosts.add(this);
            hosts.add(getParent());
        }
        if((request instanceof ReconnectRequest)) {
            ReconnectRequest reconnect = (ReconnectRequest)request;
            hosts.add(this);
            hosts.add(getParent());
            if(reconnect.getTarget() != null) {
                EditPart target  = reconnect.getTarget();
                addEditPartAndParent(hosts, target);
            }
            if(reconnect.getConnectionEditPart() != null) {
                org.eclipse.gef.ConnectionEditPart connectionEditPart = reconnect.getConnectionEditPart();
                if(connectionEditPart.getSource() != null) {
                    EditPart srcEP = connectionEditPart.getSource();
                    addEditPartAndParent(hosts, srcEP);
                }
                if(connectionEditPart.getTarget() != null) {
                    EditPart trgEP = connectionEditPart.getTarget();
                    addEditPartAndParent(hosts, trgEP);
                }
            }
        }
        if ((request instanceof CreateConnectionRequest) ) {
            CreateConnectionRequest ccvr = (CreateConnectionRequest)request;
            hosts.add(this);
            hosts.add(getParent());
            if ( ccvr.getSourceEditPart() != null ) {
                hosts.add( ccvr.getSourceEditPart());
                hosts.add( ccvr.getSourceEditPart().getParent());
            }
            if ( ccvr.getTargetEditPart() != null ) {
                hosts.add( ccvr.getTargetEditPart());
                hosts.add( ccvr.getTargetEditPart().getParent());
            }
        }
        if ((request instanceof GroupRequest)) {
            List parts = ((GroupRequest)request).getEditParts();
            hosts.add(this);
            hosts.add(getParent());
        
            Iterator editparts = parts == null ? Collections.EMPTY_LIST.iterator() : parts.iterator();  
            while ( editparts.hasNext() ) {
                EditPart ep = (EditPart)editparts.next();
                addEditPartAndParent(hosts, ep);
            }
        }
        
        /////////////////////////////////////////////////////////////
        // This following behavior is specific to BorderItemEditPart and
        // AbstractBorderItemEditPart, but we do not want to allow clients to
        // override this method so we do not want to make it protected.
        
        if (this instanceof IBorderItemEditPart) {
            if ((request instanceof CreateConnectionViewRequest)) {
                CreateConnectionViewRequest ccvr = (CreateConnectionViewRequest) request;
                if (ccvr.getSourceEditPart() instanceof IBorderItemEditPart) {
                    hosts.add(ccvr.getSourceEditPart().getParent().getParent());
                }
                if (ccvr.getTargetEditPart() instanceof IBorderItemEditPart) {
                    hosts.add(ccvr.getTargetEditPart().getParent().getParent());
                }
            }
        }
        /////////////////////////////////////////////////////////////

        return hosts;
    }

    private void addEditPartAndParent(Set hosts, EditPart editPart) {
        hosts.add(editPart);
        hosts.add(editPart.getParent());
    }

    /**
     * gets the content pane for the supplied editpart.
     * @param editPart the edit part to use to get the contents pane
     * @return <code>IFigure</code>
     */
    protected IFigure getContentPaneFor(IGraphicalEditPart editPart) {
        return getContentPane();
    }

    /**
     * Convenience method returning the editpart's parimary view. 
     * @return the diagram
     */
    protected Diagram getDiagramView() {
        return ((View) getRoot().getContents().getModel()).getDiagram();
    }

    /**
     * Convenience method returning the editpart's parimary view. Same as
     * calling <code>getView().getPrimaryView()</code>
     */
    public View getPrimaryView() {
    	if (this instanceof IPrimaryEditPart && getModel() instanceof View) {
    		return (View) getModel();
    	} else {
    		for (EditPart ep = getParent(); ep != null; ep = ep.getParent()) {
    			if (ep instanceof IGraphicalEditPart && ep.getModel() instanceof View) {
    				return ((IGraphicalEditPart) ep).getPrimaryView();
    			}
    		}
    	}
    	return null;
    }

    /**
     * gets this editpart's edit domain.
     * @return the edit domain
     */
    protected EditDomain getEditDomain() {
        EditDomain result = null;

        try {
            result = getRoot().getViewer().getEditDomain();
        } catch (NullPointerException nullPointerException) {
            /*
             * The reason why we would the code in try block throws a NPE is
             * partly because when the diagram is saved as another diagram, the
             * an event is generated which forces the refreshing of the
             * properties and if the selection is this editpart, then in order
             * to open a read action, properties provider will grab its
             * editDomain. Since this editPart would be in the state of flux and
             * may not have the root or the viewer set yet, therefore, a null
             * pointer exception can be thrown.
             *  
             */
            return null;
        }
        return result;
    }

    /** Return the editpart's diagram edit domain. */
    public IDiagramEditDomain getDiagramEditDomain() {
        return (IDiagramEditDomain) getEditDomain();
    }

    /**
     * Return this editpart's view (model) children.
     * 
     * @return list of views.
     */
    protected List getModelChildren() {
        Object model = getModel();
        if(model!=null && model instanceof View){
            return new ArrayList(((View)model).getVisibleChildren());
        }
        return Collections.EMPTY_LIST;
    }
    
    /**
     * Convenience method to retreive the value for the supplied value from the
     * editpart's associated view element. Same as calling
     * <code> ViewUtil.getStructuralFeatureValue(getNotationView(),feature)</code>.
     */
    public Object getStructuralFeatureValue(EStructuralFeature feature) {
        if (hasNotationView())
            return ViewUtil.getPropertyValue((View) super.getModel(), feature,
                feature.getEContainingClass());
        else
            return null;
    }

    
    /**
     * gets the semantic element associated to this editpart.
     * @return the semantic element or <code>null</code> if the semantic element was
     * <code>null</code> or unresolvable 
     */
    public EObject resolveSemanticElement() {
        EObject semanticElement = null;
        Object basicModel = basicGetModel();
        if (hasNotationView()) {
            semanticElement = ((View) basicModel).getElement();
        } else if (basicModel instanceof EObject) {
            semanticElement = (EObject) basicModel;
        }
        if (semanticElement == null) {
            return null;
        }

        if (!semanticElement.eIsProxy()) {
            return semanticElement;
        }

        try {
            return (EObject) getEditingDomain().runExclusive(
                new RunnableWithResult.Impl() {

                    public void run() {
                        Object model = getModel();
                        if (model instanceof View) {
                            setResult(ViewUtil
                                .resolveSemanticElement((View) getModel()));
                        } else if (model instanceof EObject) {
                            EObject element = (EObject) model;
                            if (element.eIsProxy())
                                setResult(EMFCoreUtil.resolve(
                                    getEditingDomain(), element));
                            else
                                setResult(element);
                        }
                    }
                });
        } catch (InterruptedException e) {
            Trace.catching(DiagramUIPlugin.getInstance(),
                DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(),
                "resolveSemanticElement", e); //$NON-NLS-1$
            Log.error(DiagramUIPlugin.getInstance(),
                DiagramUIStatusCodes.IGNORED_EXCEPTION_WARNING,
                "resolveSemanticElement", e); //$NON-NLS-1$
            return null;
        }

    }

    /**
     * Walks up the editpart hierarchy to find and return the
     * <code>TopGraphicEditPart</code> instance.
     */
    public TopGraphicEditPart getTopGraphicEditPart() {
        EditPart editPart = this;
        while (editPart instanceof IGraphicalEditPart) {
            if (editPart instanceof TopGraphicEditPart)
                return (TopGraphicEditPart) editPart;
            editPart = editPart.getParent();
        }
        return null;
    }

    /**
     * Return the editpart's associated Notation View.
     * @return <code>View</code>, the associated view or null if there is no associated Notation View
     */
    public View getNotationView() {
        Object model = getModel();
        if (model instanceof View)
            return (View)model;
        return null;
    }

    /**
     * Method reactivateSemanticModel. This method reactivates the edit part's
     * emantic model by: 1- removing semantic listeners 2- adding semantic
     * listeners if the semantic reference is resolvable 3- Refreshing it
     * 
     * This method is called in response to IView's Properties.ID_SEMANTICREF
     * property change event However, it will only work under the following
     * assumptions: 1- The old and new semantic models are compatible in their
     * kind 2- The deltas between old and new semantic models do not affect
     * notation 3- Connections are not refereshed since they are maintained by
     * the diagram
     */
    protected void reactivateSemanticModel() {
        removeSemanticListeners();
        if (resolveSemanticElement() != null)
            addSemanticListeners();
    }

    /** Finds an editpart given a starting editpart and an EObject */
    public EditPart findEditPart(EditPart epBegin, EObject theElement) {
        if (theElement == null) {
            return null;
        }
        EditPart epStart = null;
        if (epBegin == null) {
            epStart = this;
        } else {
            epStart = epBegin;
        }

        final View view = (View) ((IAdaptable) epStart)
            .getAdapter(View.class);

        if (view != null) {
            EObject el = ViewUtil.resolveSemanticElement(view);

            if ((el != null) && el.equals(theElement)) {
                return epStart;
            }
        }

        ListIterator childLI = epStart.getChildren().listIterator();
        while (childLI.hasNext()) {
            EditPart epChild = (EditPart) childLI.next();

            EditPart elementEP = findEditPart(epChild, theElement);
            if (elementEP != null) {
                return elementEP;
            }
        }
        return null;
    }

    /** Invoke the editpart's refresh mechanism. */
    public void refresh() {
        try {
            getEditingDomain().runExclusive(new Runnable() {
    
                public void run() {
                    EditPolicyIterator i = getEditPolicyIterator();
                    while (i.hasNext()) {
                        EditPolicy policy = i.next();
                        if (policy instanceof GraphicalEditPolicyEx) {
                            ((GraphicalEditPolicyEx) policy).refresh();
                        }
                    }
                    GraphicalEditPart.super.refresh();
                }
            });
        } catch (InterruptedException e) {
            Trace.catching(DiagramUIPlugin.getInstance(),
                DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(),
                "refresh", e); //$NON-NLS-1$
            Log.error(DiagramUIPlugin.getInstance(),
                DiagramUIStatusCodes.IGNORED_EXCEPTION_WARNING,
                "refresh", e); //$NON-NLS-1$
        }

    }

    /** Refresh the editpart's figure background colour. */
    protected void refreshBackgroundColor() {
        FillStyle style = (FillStyle)getPrimaryView().getStyle(NotationPackage.Literals.FILL_STYLE);
        if ( style != null ) {
            setBackgroundColor(DiagramColorRegistry.getInstance().getColor(new Integer(style.getFillColor())));
        }
    }

    /** Refresh the editpart's figure font. */
    protected void refreshFont() {
        FontStyle style = (FontStyle) getPrimaryView().getStyle(NotationPackage.Literals.FONT_STYLE);
        if (style != null) {
            setFont(new FontData(
                style.getFontName(), 
                style.getFontHeight(), 
                (style.isBold() ? SWT.BOLD : SWT.NORMAL) | 
                (style.isItalic() ? SWT.ITALIC : SWT.NORMAL)));
        }
    }

    /** Refresh the editpart's figure font colour. */
    protected void refreshFontColor() {
        FontStyle style = (FontStyle)  getPrimaryView().getStyle(NotationPackage.Literals.FONT_STYLE);
        if ( style != null ) {
            setFontColor(DiagramColorRegistry.getInstance().getColor(new Integer(style.getFontColor())));
        }
    }

    /** Refresh the editpart's figure foreground colour. */
    protected void refreshForegroundColor() {
        LineStyle style = (LineStyle)  getPrimaryView().getStyle(NotationPackage.Literals.LINE_STYLE);
        if ( style != null ) {
            setForegroundColor(DiagramColorRegistry.getInstance().getColor(new Integer(style.getLineColor())));
        }
    }

    /** Refresh the editpart's figure visibility. */
    protected void refreshVisibility() {
        Object model = null;
        EditPart ep = this;
        while (!(model instanceof View) && ep!=null){
            model = ep.getModel();
            ep = ep.getParent();
        }
        if (model instanceof View)
            setVisibility(((View)model).isVisible());
    }

    /** Refresh the editpart's figure visual properties. */
    protected void refreshVisuals() {
        super.refreshVisuals();
        refreshVisibility();
    }

    /**
     * Removes a listener previously added with the given id
     * 
     * @param filterId the filter ID
     */
    protected void removeListenerFilter(String filterId) {
        if (listenerFilters == null)
            return;
        Object[] objects = (Object[]) listenerFilters.remove(filterId);
        if (objects == null)
            return;
        if (objects.length>2){
            getDiagramEventBroker().
                removeNotificationListener((EObject) objects[0],
                                             (EStructuralFeature) objects[1],
                                             (NotificationListener) objects[2]);
        }else{
            getDiagramEventBroker().removeNotificationListener((EObject) objects[0],(NotificationListener) objects[1]);
        }
        
    }

    /**
     * sets the back ground color of this edit part
     * @param color the new value of the back ground color
     */
    protected void setBackgroundColor(Color color) {
        getFigure().setBackgroundColor(color);
    }

    /**
     * Sets the font to the label.
     * This method could be overriden to change the font data of the font
     * overrides typically look like this:
     *      super.setFont(
     *      new FontData(
     *          fontData.getName(),
     *          fontData.getHeight(),
     *          fontData.getStyle() <| &> SWT.????));
     * @param fontData the font data
     */
    protected void setFont(FontData fontData) {
         if (cachedFontData != null && cachedFontData.equals(fontData)) {
            // the font was previously set and has not changed; do nothing.
            return;
        }

        try {
            Font newFont = getResourceManager().createFont(
                FontDescriptor.createFrom(fontData));
            getFigure().setFont(newFont);
            getFigure().repaint();

            if (cachedFontData != null) {
                getResourceManager().destroyFont(
                    FontDescriptor.createFrom(cachedFontData));
            }
            cachedFontData = fontData;
        } catch (DeviceResourceException e) {
            Trace.catching(DiagramUIPlugin.getInstance(),
                DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(),
                "setFont", e); //$NON-NLS-1$
            Log.error(DiagramUIPlugin.getInstance(),
                DiagramUIStatusCodes.IGNORED_EXCEPTION_WARNING, "setFont", e); //$NON-NLS-1$
        }
    }

    /**
     * sets the font color
     * @param color the new value of the font color
     */
    protected void setFontColor(Color color) {
        // NULL implementation
    }

    /**
     * sets the fore ground color of this edit part's figure
     * @param color the new value of the foregroundcolor
     */
    protected void setForegroundColor(Color color) {
        getFigure().setForegroundColor(color);
    }
    
    /**
     * Sets the passed feature if possible on this editpart's view
     * to the passed value.
     * @param feature the feature to use
     * @param value  the value of the property being set
     */
    public void setStructuralFeatureValue(EStructuralFeature feature, Object value) {
        if (hasNotationView() && (feature != null)) {
            ViewUtil.setPropertyValue((View) super.getModel(), feature, feature
                .getEContainingClass(), value);
        }
    }

    /**
     * sets the visibility of this edit part
     * @param vis the new value of the visibility
     */
    protected void setVisibility(boolean vis) {
        if (!vis && getSelected() != SELECTED_NONE)
            getViewer().deselect(this);
        
        IFigure _figure = getFigure();
        if (_figure.isVisible()==vis){
            return;
        }
        
        // if we are going to hide the node then connections coming to the
        // node or outside it should be hidden as well
        if (getFlag(FLAG__AUTO_CONNECTIONS_VISIBILITY)) {
        	setConnectionsVisibility(vis);
        }
        _figure.setVisible(vis);
        _figure.revalidate();
    }
    
    protected void setConnectionsVisibility(boolean visibility) {
        List _srcConnections = getSourceConnections();
        for (Iterator iter = _srcConnections.iterator(); iter.hasNext();) {
            ConnectionEditPart connection = (ConnectionEditPart) iter.next();
            if (connection.getFigure().isVisible()!=visibility)
                connection.setVisibility(visibility);
        }
        
        List _targetConnections = getTargetConnections();
        for (Iterator iter = _targetConnections.iterator(); iter.hasNext();) {
            ConnectionEditPart connection = (ConnectionEditPart) iter.next();
            if (connection.getFigure().isVisible()!=visibility)
                connection.setVisibility(visibility);
        }
        
    }

    /**
     * This method adds all listeners to the notational world (views, figures,
     * editpart...etc) Override this method to add more notational listeners
     * down the hierarchy
     */
    protected void addNotationalListeners() {
        if (hasNotationView()){
            addListenerFilter("View", this,(View)getModel()); //$NON-NLS-1$
        }
    }
    
    /**
     * This method adds all listeners to the semantic element behind this EditPart
     * Override this method to add more semantic listeners down the hierarchy
     * This method is called only if the semantic element is resolvable
     */
    protected void addSemanticListeners() {
        addListenerFilter("SemanticElement", this,resolveSemanticElement());//$NON-NLS-1$
    }

    /**
     * This method removes all listeners to the notational world (views,
     * figures, editpart...etc) Override this method to remove notational
     * listeners down the hierarchy
     */
    protected void removeNotationalListeners() {
        removeListenerFilter("View"); //$NON-NLS-1$
    }

    /**
     * This method removes all listeners to the semantic element behind this EditPart
     * Override this method to remove semantic listeners
     * down the hierarchy
     */
    protected void removeSemanticListeners() {
        removeListenerFilter("SemanticElement"); //$NON-NLS-1$
    }

    /**
     * Perform a request by executing a command from the target editpart of the
     * request For the Direct_Edit request, we need to show up an editor first
     * 
     * @see org.eclipse.gef.EditPart#performRequest(org.eclipse.gef.Request)
     */
    public void performRequest(Request request) {
        if ( !isEditModeEnabled() ) {
            if (RequestConstants.REQ_OPEN.equals(request.getType())) {
                //allowed, continue
            }
            else {
                return;
            }
        }
        
        if (RequestConstants.REQ_DIRECT_EDIT == request.getType()) {
            performDirectEditRequest(request);
        } else {
            EditPart targetEditPart = getTargetEditPart(request);
            if (targetEditPart != null) {
                Command command = targetEditPart.getCommand(request);
                if (command != null) {
                    getDiagramEditDomain().getDiagramCommandStack().execute(
                        command);
                    return;
                }
            }
        }
    }

    /**
     * Performs a direct edit request (usually by showing some type of editor)
     * 
     * @param request
     *            the direct edit request
     */
    protected void performDirectEditRequest(Request request) {
        // NULL implementation
    }

    /**
     * @see org.eclipse.gef.editparts.AbstractEditPart#getAccessibleEditPart()
     */
    protected AccessibleEditPart getAccessibleEditPart() {
        if (accessibleEP == null)
            accessibleEP = new AccessibleGraphicalEditPart() {

            private String getSemanticName() {
                EObject semanticElement = resolveSemanticElement();
            
                if( semanticElement != null ) {
                    String name = semanticElement.getClass().getName();
                    int startIndex = name.lastIndexOf('.') + 1;
                    int endIndex = name.lastIndexOf( "Impl" ); //$NON-NLS-1$
                    return name.substring(startIndex, endIndex);
                }
            
                return null;
            }

            public void getName(AccessibleEvent e) {
                IGraphicalEditPart childEP = getChildBySemanticHint(CommonParserHint.NAME);
                if (childEP == null) {
                    childEP = getChildBySemanticHint(CommonParserHint.DESCRIPTION);
                }
                if (childEP != null) {
                    ILabelDelegate label = (ILabelDelegate) childEP.getAdapter(ILabelDelegate.class);
                    if (label != null) {
                        e.result = label.getText();
                    }
                } else {
                    e.result = getSemanticName();
                }
            }
            };

        return accessibleEP;
    }

    /** Adds a [ref, editpart] mapping to the EditPartForElement map. */
    protected void registerModel() {
        EditPartViewer viewer = getViewer();
        if (hasNotationView()) {
            super.registerModel();
        } else {
            viewer.getEditPartRegistry().put(basicGetModel(), this);
        }

        // Save the elements Guid to use during unregister.
        // If the reference is null, do not register.
        EObject ref = null;
        if (hasNotationView())
            ref = getNotationView().getElement();
        else
            ref = (EObject) basicGetModel();
        if (ref == null) {
            return;
        }
        elementGuid = EMFCoreUtil.getProxyID(ref);
        ((IDiagramGraphicalViewer) viewer).registerEditPartForElement(
            elementGuid, this);
    }


    /** Remove this editpart from the EditPartForElement map. */
    protected void unregisterModel() {
        EditPartViewer viewer = getViewer();
        if (hasNotationView())
            super.unregisterModel();
        else {
            Map registry = viewer.getEditPartRegistry();
            if (registry.get(basicGetModel()) == this)
                registry.remove(basicGetModel());
        }

        //Do not need to unregister if the guid is null.
        if (elementGuid == null) {
            return;
        }
        ((IDiagramGraphicalViewer) viewer).unregisterEditPartForElement(
            elementGuid, this);
    }

    /**
     * Refreshes a child editpart by removing it and refreshing children
     * @param child the child to refresh
     */
    protected final void refreshChild(GraphicalEditPart child) {
        removeChild(child);
        refreshChildren();
    }
    
    /**
     * Refreshes a source connection editpart by removing it and refreshing source connections
     * @param conn the connection to refresh
     */
    protected final void refreshSourceConnection(ConnectionEditPart conn) {
        removeSourceConnection(conn);
        refreshSourceConnections();
    }

    /**
     * Refreshes a target connection editpart by removing it and refreshing target connections
     * @param conn the connection to refresh
     */
    protected final void refreshTargetConnection(ConnectionEditPart conn) {
        removeTargetConnection(conn);
        refreshTargetConnections();
    }

    /**
     * Handles the case where the semantic reference has changed.
     */
    protected final void handleMajorSemanticChange() {
        if (getParent() instanceof GraphicalEditPart)
            ((GraphicalEditPart) getParent()).refreshChild(this);
        else if (getParent() instanceof ConnectionEditPart)
            ((ConnectionEditPart) getParent()).refreshChild(this);
    }
    
    /**
     * @see org.eclipse.gef.EditPart#getDragTracker(org.eclipse.gef.Request)
     */
    public DragTracker getDragTracker(Request request) {
        return new DragEditPartsTrackerEx(this);
    }

    /**
     * @return <tt>true</tt> a canonical editpolicy has been installed on this editpart
     * and it is active; otherwise <tt>false</tt>.
     */
    public boolean isCanonical() {
        CanonicalEditPolicy policy = (CanonicalEditPolicy)getEditPolicy(EditPolicyRoles.CANONICAL_ROLE);
        return policy == null ? false : policy.isActive();
    }

    /**
     * Return <tt>true</tt> if the editpart's figure is visible;
     * <tt>false</tt> otherwise.
     */
    public boolean isSelectable() {
        return getFigure().isShowing();
    }

    /* 
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart#disableEditMode()
     */
    public void disableEditMode() {
        if (!isEditModeEnabled()) {
            return;
        }

        List l = getSourceConnections();
        int size = l.size();
        for (int i = 0; i < size; i++) {
            Object obj = l.get(i);
            if (obj instanceof IEditableEditPart) {
                ((IEditableEditPart) obj).disableEditMode();
            }
        }

        List c = getChildren();
        size = c.size();
        for (int i = 0; i < size; i++) {
            Object obj = c.get(i);
            if (obj instanceof IEditableEditPart) {
                ((IEditableEditPart) obj).disableEditMode();
            }
        }

        setFlag(FLAG__IS_EDITABLE, false);
    }
    
    
    protected void addChild(EditPart child, int index) {
        super.addChild(child, index);
        if (child instanceof GraphicalEditPart){
            GraphicalEditPart gEP = (GraphicalEditPart)child;
            boolean editMode = isEditModeEnabled(); 
            if (editMode != gEP.isEditModeEnabled()){
                if (editMode)
                    gEP.enableEditMode();
                else
                    gEP.disableEditMode();
            }
        }
    }

    /* 
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart#enableEditMode()
     */
    public void enableEditMode() {
        if (isEditModeEnabled()) {
            return;
        }

        setFlag(FLAG__IS_EDITABLE, true);

        List c = getChildren();
        int size = c.size();
        for (int i = 0; i < size; i++) {
            Object obj = c.get(i);
            if (obj instanceof IEditableEditPart) {
                ((IEditableEditPart) obj).enableEditMode();
            }
        }

        List l = getSourceConnections();
        size = l.size();
        for (int i = 0; i < size; i++) {
            Object obj = l.get(i);
            if (obj instanceof IEditableEditPart) {
                ((IEditableEditPart) obj).enableEditMode();
            }
        }
    }
    
    /* 
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart#isEditModeEnabled()
     */
    public boolean isEditModeEnabled() {
        // protect against deadlock - don't allow any action while write transaction
        // is active on another thread
        if (EditPartUtil.isWriteTransactionInProgress(this, true, true))
            return false;
        return getFlag(FLAG__IS_EDITABLE);
    }
    
    /* 
     * @see org.eclipse.gef.EditPart#showSourceFeedback(org.eclipse.gef.Request)
     */
    public void showSourceFeedback(Request request) {
        if ( !isEditModeEnabled()) {
            return;
        }
        
        super.showSourceFeedback(request);
    }
    
    /* 
     * @see org.eclipse.gef.EditPart#showTargetFeedback(org.eclipse.gef.Request)
     */
    public void showTargetFeedback(Request request) {
        if ( !isEditModeEnabled()) {
            return;
        }
        
        super.showTargetFeedback(request);
    }

    /* 
     * @see org.eclipse.gef.EditPart#eraseSourceFeedback(org.eclipse.gef.Request)
     */
    public void eraseSourceFeedback(Request request) {
        if ( !isEditModeEnabled()) {
            return;
        }
        
        super.eraseSourceFeedback(request);
    }
    /* 
     * @see org.eclipse.gef.EditPart#eraseTargetFeedback(org.eclipse.gef.Request)
     */
    public void eraseTargetFeedback(Request request) {
        if ( !isEditModeEnabled()) {
            return;
        }

        super.eraseTargetFeedback(request);
    }
    
    /**
     * this method will return the primary child EditPart  inside this edit part
     * @return the primary child view inside this edit part
     */
    public EditPart getPrimaryChildEditPart(){
        if (getChildren().size() > 0)
            return (EditPart) getChildren().get(0);
        return null;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart#getDiagramPreferencesHint()
     */
    public PreferencesHint getDiagramPreferencesHint() {
        RootEditPart root = getRoot();
        if (root instanceof IDiagramPreferenceSupport) {
            return ((IDiagramPreferenceSupport) root).getPreferencesHint();
        }
        return PreferencesHint.USE_DEFAULTS;
    }

    public void notifyChanged(Notification notification) {
        if (isActive()){
            handleNotificationEvent(notification);
        }
    }
    
    public Command transactionAboutToCommit(Notification notification) {
        return null;
    }

    
    /**
     * Handles the property changed event.  Clients should override to
     * respond to the specific notification events they are interested.
     * 
     * Note: This method may get called on a non-UI thread.  Clients should
     * either ensure that their code is thread safe and/or doesn't make
     * unsupported calls (i.e. Display.getCurrent() ) assuming they are on
     * the main thread.  Alternatively if this is not possible, then the
     * client can wrap their handler within the Display.synchExec runnable
     * to ensure synchronization and subsequent execution on the main thread.
     * 
     * @param event
     *            the <code>Notification</code> object that is the property changed event
     */
    protected void handleNotificationEvent(Notification event) {        
        if (NotationPackage.Literals.VIEW__PERSISTED_CHILDREN.equals(event.getFeature())||
                NotationPackage.Literals.VIEW__TRANSIENT_CHILDREN.equals(event.getFeature())) {
            refreshChildren();
        }else if (NotationPackage.Literals.VIEW__VISIBLE.equals(event.getFeature())) {
            Object notifier = event.getNotifier();
            if (notifier== getModel())
                refreshVisibility();
            else{
                // refresh the children only if the notificatino is not comming for and edge
                // sincethe children list had no edges
                if (!(event.getNotifier() instanceof Edge))
                    refreshChildren();
            }
        }
        else if (NotationPackage.Literals.VIEW__ELEMENT.equals(event.getFeature())) {
            handleMajorSemanticChange();
        } 
    }
    
    /**
     * @return <code>IMapMode</code> that allows for the coordinate mapping from device to
     * logical units. 
     */
     protected IMapMode getMapMode() {
        RootEditPart root = getRoot();
        if (root instanceof DiagramRootEditPart) {
            DiagramRootEditPart dgrmRoot = (DiagramRootEditPart)root;
            return dgrmRoot.getMapMode();
        }
        
        return MapModeUtil.getMapMode();
    }
    
    /**
     * indicates if this edit part's model is a view or not 
     * @return <code>true</code> or <code>false</code>
     */
    public boolean hasNotationView(){
        return true;
    }
    
    /**
     * Returns tis edit part's model; the returned values is not granteed to be 
     * <code>View</code>, the return value could be null or any Object depending
     * on the edit part implementation 
     * 
     */
    public Object getModel() {
        if (hasNotationView()){
            return super.getModel();
        } else {
            Object _model = basicGetModel();
            Node node = NotationFactory.eINSTANCE.createNode();;
            node.setElement((EObject)_model);
            return node;
        }
    }
    
    /**
     * Derives my editing domain from my model or my diagram element. Subclasses
     * may override.
     */
    public TransactionalEditingDomain getEditingDomain() {
        if (editingDomain == null) {
            // try to get the editing domain for the model
            editingDomain = TransactionUtil.getEditingDomain(getModel());
            
            if (editingDomain == null) {
                // try to get the editing domain from the diagram view
                editingDomain = TransactionUtil.getEditingDomain(getDiagramView());
            }
        }
        return editingDomain;
    }
    
    protected IFigure createFigure() {
        // TODO Auto-generated method stub
        return null;
    }

    public void setModel(Object model) {
        // reset the editing domain cache
        editingDomain = null;
        super.setModel(model);
    }

    /**
     * Gets the diagram event broker from the editing domain.
     * 
     * @return the diagram event broker
     */
    private DiagramEventBroker getDiagramEventBroker() {
        TransactionalEditingDomain theEditingDomain = getEditingDomain();
        if (theEditingDomain != null) {
            return DiagramEventBroker.getInstance(theEditingDomain);
        }
        return null;
    }

    // documentation copied from superclass
    public RootEditPart getRoot() {
        if (getParent() != null) {
            return super.getRoot();
        }
        return null;
    }
    
   public Object getPreferredValue(EStructuralFeature feature) {
        Object preferenceStore = getDiagramPreferencesHint()
            .getPreferenceStore();
        if (preferenceStore instanceof IPreferenceStore) {
            if (feature == NotationPackage.eINSTANCE.getLineStyle_LineColor()) {
                
                return FigureUtilities.RGBToInteger(PreferenceConverter
                    .getColor((IPreferenceStore) preferenceStore,
                        IPreferenceConstants.PREF_LINE_COLOR));
                
            } else if (feature == NotationPackage.eINSTANCE
                .getFontStyle_FontColor()) {
                
                return FigureUtilities.RGBToInteger(PreferenceConverter
                    .getColor((IPreferenceStore) preferenceStore,
                        IPreferenceConstants.PREF_FONT_COLOR));
                
            } else if (feature == NotationPackage.eINSTANCE
                .getFillStyle_FillColor()) {
                
                return FigureUtilities.RGBToInteger(PreferenceConverter
                    .getColor((IPreferenceStore) preferenceStore,
                        IPreferenceConstants.PREF_FILL_COLOR));
                
            }
        }

        return getStructuralFeatureValue(feature);
    }    
    /**
     * Gets the resource manager to remember the resources allocated for this
     * graphical viewer. All resources will be disposed when the graphical
     * viewer is closed if they have not already been disposed.
     * 
     * @return the resource manager
     */
    protected ResourceManager getResourceManager() {
        EditPartViewer viewer = getViewer();
        if (viewer instanceof DiagramGraphicalViewer) {
            return ((DiagramGraphicalViewer) viewer).getResourceManager();
        }
        return JFaceResources.getResources();
    }    
    
	/**
	 * Set the line width of the shape. Clients need to override if they support
	 * line width.
	 * 
	 * @param width
	 *            the line width.
	 */
	protected void setLineWidth(int width) {
		/* not implemented */
	}

	/**
	 * Get the line width of the shape.
	 * 
	 * @return width the line width.
	 */
	protected int getLineWidth() {
		/* a default of -1 means the diagram does not implement line width */
		int lineWidth = -1;

		LineStyle style = (LineStyle) getPrimaryView().getStyle(
				NotationPackage.eINSTANCE.getLineStyle());
		if (style != null) {
			lineWidth = style.getLineWidth();
		}

		return lineWidth;
	}

	/**
	 * Refresh the line width of the shape.
	 */
	protected void refreshLineWidth() {
		setLineWidth(getLineWidth());
	}

	/**
	 * Set the line type of the shape. Clients need to override if they support
	 * line type.
	 * 
	 * @param lineType
	 *            the line type.
	 */
	protected void setLineType(int lineType) {
		/* not implemented */
	}

	/**
	 * Get the line type of the shape.
	 * 
	 * @return the line type.
	 */
	protected int getLineType() {
		// default to a solid line.
		int lineType = Graphics.LINE_SOLID;

		LineTypeStyle style = (LineTypeStyle) getPrimaryView().getStyle(
				NotationPackage.eINSTANCE.getLineTypeStyle());
		if (style != null) {
			if (style.getLineType() == LineType.SOLID_LITERAL) {
				lineType = Graphics.LINE_SOLID;
			} else if (style.getLineType() == LineType.DASH_LITERAL) {
				lineType = Graphics.LINE_DASH;
			} else if (style.getLineType() == LineType.DOT_LITERAL) {
				lineType = Graphics.LINE_DOT;
			} else if (style.getLineType() == LineType.DASH_DOT_LITERAL) {
				lineType = Graphics.LINE_DASHDOT;
			} else if (style.getLineType() == LineType.DASH_DOT_DOT_LITERAL) {
				lineType = Graphics.LINE_DASHDOTDOT;
			}
		}

		return lineType;
	}

	/**
	 * Refresh the line type of the shape.
	 */
	protected void refreshLineType() {
		setLineType(getLineType());
	}
	
	/**
	 * Sets the flag for automatically refreshing source/target connections visibility based on the editpart's
	 * visibility (i.e. {@link #setConnectionsVisibility(boolean) will be called}
	 * 
	 * @param autoRefreshConnectionsVisibility <code>true</code> to set automatic refresh to on
	 * @since 1.2
	 */
	public void setAutomaticalRefreshConnectionsVisibility(boolean autoRefreshConnectionsVisibility) {
		setFlag(FLAG__AUTO_CONNECTIONS_VISIBILITY, autoRefreshConnectionsVisibility);
	}
	
	/**
	 * Returns <code>true</code if automatic update of source/target connections visibility is triggered by editpart's visibility (i.e. {@link #setConnectionsVisibility(boolean) is being called}
	 * 
	 * @return <code>true</code> if automatic visibility refresh for connections is on
	 * @since 1.2
	 */
	public boolean isAutomaticalRefreshConnectionsVisibility() {
		return getFlag(FLAG__AUTO_CONNECTIONS_VISIBILITY);
	}

}