//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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 implementation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.diagram.core.part.util;

import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.emf.workspace.AbstractEMFOperation;
import org.eclipse.epf.common.CommonPlugin;
import org.eclipse.epf.diagram.core.DiagramCorePlugin;
import org.eclipse.epf.diagram.core.bridge.ActivityDiagramAdapter;
import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
import org.eclipse.epf.diagram.core.bridge.DiagramAdapter;
import org.eclipse.epf.diagram.core.bridge.NodeAdapter;
import org.eclipse.epf.diagram.core.part.AbstractDiagramEditor;
import org.eclipse.epf.diagram.core.part.DiagramEditorInput;
import org.eclipse.epf.diagram.core.part.DiagramEditorInputProxy;
import org.eclipse.epf.diagram.core.part.DiagramFileEditorInputProxy;
import org.eclipse.epf.diagram.core.part.IDiagramEditorInputProvider;
import org.eclipse.epf.diagram.core.part.IDiagramFileEditorInputProxy;
import org.eclipse.epf.diagram.core.providers.SharedResourceDiagramDocumentProvider;
import org.eclipse.epf.diagram.core.resources.IDiagramStorage;
import org.eclipse.epf.diagram.core.services.DiagramManager;
import org.eclipse.epf.diagram.core.util.DiagramCoreUtil;
import org.eclipse.epf.diagram.model.ActivityDetailDiagram;
import org.eclipse.epf.diagram.model.ModelFactory;
import org.eclipse.epf.diagram.model.NamedNode;
import org.eclipse.epf.diagram.model.NodeContainer;
import org.eclipse.epf.diagram.model.RoleTaskComposite;
import org.eclipse.epf.diagram.model.WorkProductDependencyDiagram;
import org.eclipse.epf.diagram.model.impl.DiagramImpl;
import org.eclipse.epf.diagram.model.impl.NodeImpl;
import org.eclipse.epf.diagram.model.util.TxUtil;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.util.IDiagramManager;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.Suppression;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.gef.ConnectionEditPart;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gmf.runtime.common.core.util.StringStatics;
import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionNodeEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.GraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ITextAwareEditPart;
import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocumentProvider;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.FontStyle;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;

/**
 * @author Phong Nguyen Le
 * @author skannoor
 * @since 1.2
 */
public class DiagramEditorUtil {
	private static final String AD_EDITOR_ID = "org.eclipse.epf.diagram.ad.part.ActivityDiagramEditorID"; //$NON-NLS-1$
	private static final String ADD_EDITOR_ID = "org.eclipse.epf.diagram.add.part.ActivityDetailDiagramEditorID"; //$NON-NLS-1$
	private static final String WPDD_EDITOR_ID = "org.eclipse.epf.diagram.wpdd.part.WorkProductDependencyDiagramEditorID"; //$NON-NLS-1$

	public static String getEditorId(int diagramType) {
		switch(diagramType) {
		case IDiagramManager.ACTIVITY_DIAGRAM:
			return AD_EDITOR_ID;
		case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
			return ADD_EDITOR_ID;
		case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
			return WPDD_EDITOR_ID;
		}
		return null;
	}

	public static IEditorPart openDiagramEditor(IWorkbenchPage page, DiagramEditorInput input, PreferencesHint hint, IProgressMonitor progressMonitor) {
		DiagramEditorInputProxy inputProxy = new DiagramEditorInputProxy(input, hint);

		IEditorPart editorPart = null;
		try {
			editorPart = page.openEditor(inputProxy, getEditorId(input.getDiagramType()), true);
		} catch (Exception e) {
			CommonPlugin.getDefault().getLogger().logError(e);
		}

		if(editorPart instanceof AbstractDiagramEditor){
			if(input.getDiagramType() == IDiagramManager.ACTIVITY_DETAIL_DIAGRAM) {
				AbstractDiagramEditor editor = ((AbstractDiagramEditor)editorPart);
				editor.resetLayout();
				// TODO: has to call resetLayout twice here so it can layout properly
				// need to improve this method
				//
				editor.resetLayout();
			}
			
			IDocumentProvider docProvider = ((DiagramDocumentEditor)editorPart).getDocumentProvider();

			// set the document as savable if the diagram is new
			//
			org.eclipse.epf.uma.Process proc = TngUtil.getOwningProcess(input.getMethodElement());
			if(proc != null) {
				DiagramManager mgr = null;
				Object consumer = new Object();
				try {
					mgr = DiagramManager.getInstance(proc, consumer);
					if(mgr != null && inputProxy.isNewDiagram()) {
						docProvider.setCanSaveDocument(inputProxy);
					}
				}
				finally {
					if(mgr != null) {
						mgr.removeConsumer(consumer);
					}
				}
			}

			// initialization might have made the document dirty
			// this will clear dirty flag of the editor
			//
			if (docProvider instanceof SharedResourceDiagramDocumentProvider
					&& editorPart.isDirty()
					&& !inputProxy.isNewDiagram()) {
				((SharedResourceDiagramDocumentProvider) docProvider)
				.markDocumentAsSaved(inputProxy);
			}			

			// Check whether diagram is read-only and plug-in is locked. 
			//
			if(!isModifiable(inputProxy)){
				((SharedResourceDiagramDocumentProvider)((AbstractDiagramEditor)editorPart).getDocumentProvider()).lock(true);
				DiagramEditPart editPart = ((IDiagramWorkbenchPart)editorPart).getDiagramEditPart();
				editPart.disableEditMode();
			}
		}
		return editorPart;
	}
	
	public static void refreshVisual(DiagramEditPart editPart) {
		// refresh labels
		//
		Iterator<Object> iter = new AbstractTreeIterator<Object>(editPart, false) {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			protected Iterator<?> getChildren(Object object) {
				if(object instanceof EditPart) {
					return ((EditPart)object).getChildren().iterator();
				}
				return Collections.EMPTY_LIST.iterator();
			}
			
		};
		while(iter.hasNext()) {
			Object child = iter.next();
			if(child instanceof ITextAwareEditPart || child instanceof ConnectionNodeEditPart) {
				((EditPart)child).refresh();
			}
		}

		// refresh connections
		//
		for (Iterator iterator = editPart.getConnections().iterator(); iterator.hasNext();) {
			ConnectionEditPart conn = (ConnectionEditPart) iterator.next();
			conn.refresh();
		}
	}
	
	public static void refreshLabels(DiagramEditPart editPart) {
//		// make sure that the edit part figure is large enough to show the icon and all the text
//		//
//		for (Iterator iterator = editPart.getChildren().iterator(); iterator.hasNext();) {
//			Object child = (Object) iterator.next();
//			if(child instanceof GraphicalEditPart) {
//				IFigure f = ((GraphicalEditPart)child).getFigure();
//				if(f instanceof DefaultSizeNodeFigure) {
//					Object f2 = ((DefaultSizeNodeFigure)f).getChildren().get(0);
//				if(f2 instanceof RectangleFigure) {
//					RectangleFigure figure = (RectangleFigure) f2;
//					List children = ((RectangleFigure)figure).getChildren();
//					if(!children.isEmpty()) {
//						Object l = children.get(0);
//						if(l instanceof WrapLabel) {
//							WrapLabel label = ((WrapLabel)l);
//							Rectangle r = figure.getBounds();
//							Dimension d = figure.getPreferredSize();
//							Rectangle textR = label.getTextBounds();							
//////							textR.width += (textR.width * WidenedWrapLabel.DELTA_FACTOR);
////							textR.width += 20;
////							if(r.width < d.width || r.height < d.height) {
////								WrapLabel label = ((WrapLabel)l);
////								label.invalidate();
////								figure.setBounds(r.union(textR));	
//////								System.out.println(label.getSubStringText());
////							}
////							if("Design the Solution".equals(label.getText())) {		
//								System.out.println("Text: '" + label.getText() + "'");
//								System.out.println("Label font: " + label.getFont());
//								System.out.println("Default font: " + DiagramConstants.DEFAULT_FONT);
//								System.out.println("Calculated text size: " + DiagramCoreUtil.getTextSizeInWrapLabel(label.getText(), null, r.width, r.height, null));
//								System.out.println("Current text width: " + textR.width);
//								System.out.println("Node width: " + r.width);
////							}
//						}
//					}
//				}
//				}
//			}			
//		}
		
		Iterator iter = new AbstractTreeIterator(editPart, false) {

			@Override
			protected Iterator getChildren(Object object) {
				if(object instanceof EditPart) {
					return ((EditPart)object).getChildren().iterator();
				}
				return Collections.EMPTY_LIST.iterator();
			}
			
		};
		while(iter.hasNext()) {
			Object child = iter.next();
			if(child instanceof ITextAwareEditPart) {
				((ITextAwareEditPart)child).refresh();
			}
		}
	}
	
	private static Diagram getDiagram(DiagramEditorInputProxy inputProxy) throws CoreException {
		IStorage storage = inputProxy.getStorage();
		return storage instanceof IDiagramStorage ? ((IDiagramStorage)storage).getDiagram() : null;
	}
	
	private static boolean doInitialize(
			final DiagramEditorInputProxy inputProxy,
			IProgressMonitor monitor) throws CoreException {
		final Diagram model = getDiagram(inputProxy);
		if(model == null) {
			return false;
		}
		if(DiagramManager.AD_kind.equals(model.getType())) {
			ActivityDiagramAdapter adapter = (ActivityDiagramAdapter) BridgeHelper.getNodeAdapter(model.getElement());
			if(adapter == null) {
				adapter = new ActivityDiagramAdapter(
								(Activity) inputProxy
										.getDiagramEditorInput().getMethodElement());
				adapter
						.setEditingDomain((InternalTransactionalEditingDomain) TransactionUtil
								.getEditingDomain(model));
				adapter.setSuppression(inputProxy
						.getDiagramEditorInput().getSuppression());
				adapter.setView(model);
				model.getElement().eAdapters().add(adapter);
			}
			adapter.populateDiagram();
			return true;
		}
		else if(DiagramManager.ADD_kind.equals(model.getType())
				|| DiagramManager.WPD_kind.equals(model.getType())) {
			TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(model);
			AbstractEMFOperation op = new AbstractEMFOperation(domain, StringStatics.BLANK) {
			
				@Override
				protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info)
						throws ExecutionException {
					org.eclipse.epf.diagram.model.Diagram d = 
						(org.eclipse.epf.diagram.model.Diagram) model.getElement();
					DiagramEditorInput input = inputProxy.getDiagramEditorInput();
					d.setSuppression(input.getSuppression());
					d.setLinkedElement(input.getMethodElement());
					d.setObject(d.getLinkedElement());

					return Status.OK_STATUS;
				}
			
			};
			try {
				op.execute(monitor, null);
				return true;
			} catch (ExecutionException e) {
				CommonPlugin.getDefault().getLogger().logError(e);
			}
		} 
		return false;
	}
	
	public static void initializeOnActivate(DiagramEditPart editPart) {
		if(editPart.getViewer() instanceof IDiagramEditorInputProvider) {
			IEditorPart editor = ((IDiagramEditorInputProvider)editPart.getViewer()).getEditor();
			if(editor != null && editor.getEditorInput() instanceof DiagramEditorInputProxy) {
				DiagramEditorInputProxy inputProxy = (DiagramEditorInputProxy) editor.getEditorInput();
				IProgressMonitor monitor = new NullProgressMonitor();
				try {
					if(doInitialize(inputProxy, monitor)) {
						doRefresh(editPart, monitor, false);
						refreshVisual(editPart);
					}
				} catch (CoreException e) {
					DiagramCorePlugin.getDefault().getLogger().logError(e);
				}
				
			}
		}
	}

	public static void initialize(final DiagramEditPart editPart, final DiagramEditorInputProxy inputProxy, IProgressMonitor monitor) {		
		try {
			if(doInitialize(inputProxy, monitor)) {
				refresh(editPart, monitor);
				refreshLabels(editPart);
			}
		} catch (CoreException e) {
			DiagramCorePlugin.getDefault().getLogger().logError(e);
		}
	}
	private static void updateEdges(View view){
		boolean allVisible = false;
		for (Iterator iter = view.getChildren().iterator(); iter.hasNext();) {
			View child = (View) iter.next();
			if(child.getElement() instanceof NodeImpl) {
				NodeImpl node = (NodeImpl)child.getElement();
				if(!node.isVisible()){
					setEdgeVisibility(view, node.isVisible());
				}else{
					child.setVisible(node.isVisible());
					setEdgeVisibility(child, true);
				}
				if(node instanceof NamedNode) {
					FontStyle style = (FontStyle) child.getStyle(NotationPackage.Literals.FONT_STYLE);
					if(style == null) {
						style = (FontStyle) child.createStyle(NotationPackage.Literals.FONT_STYLE);
					}
				}
				if(child.isVisible() && child.getElement() instanceof NodeContainer) {
					updateEdges(child);
				}
				if(node.isVisible()){
					allVisible = true;
				}
			}
		}
		if(view.getElement() instanceof NodeContainer 
				&& !(view.getElement() instanceof ActivityDetailDiagram)
				&& !(view.getElement() instanceof WorkProductDependencyDiagram)){
			setEdgeVisibility(view, allVisible);
		}
		
	}
	
	private static void setEdgeVisibility(View view, boolean visibility){
		Diagram diagram = view.getDiagram();
		for (Iterator iterator = diagram.getEdges().iterator(); iterator
				.hasNext();) {
			Edge edge = (Edge) iterator.next();
			if(edge.getSource() == view || edge.getTarget() == view){
				if(visibility){
					view.setVisible(true);
				}
				edge.setVisible(visibility);
			}
		}
	}
	
	private static void updateView(View view) {
		boolean allVisible = false;
		for (Iterator iter = view.getChildren().iterator(); iter.hasNext();) {
			View child = (View) iter.next();
			if(child.getElement() instanceof NodeImpl) {
				NodeImpl node = (NodeImpl)child.getElement();
				child.setVisible(node.isVisible());
				if(node instanceof NamedNode) {
					FontStyle style = (FontStyle) child.getStyle(NotationPackage.Literals.FONT_STYLE);
					if(style == null) {
						style = (FontStyle) child.createStyle(NotationPackage.Literals.FONT_STYLE);
					}
				}
				if(child.isVisible() && child.getElement() instanceof NodeContainer) {
					updateView(child);
				}
				if(node.isVisible()){
					allVisible = true;
				}
			}
		}
		
		if(view.getElement() instanceof NodeContainer 
				&& !(view.getElement() instanceof ActivityDetailDiagram)
				&& !(view.getElement() instanceof WorkProductDependencyDiagram)) {
//			if(!allVisible) {
//				System.out.println();
//			}
			view.setVisible(allVisible);
		}
	}
	
	public static boolean isInherited(EditPart editPart) {
		EditPartViewer viewer = editPart.getViewer();
		if(viewer instanceof IDiagramEditorInputProvider) {
			DiagramEditorInput input = ((IDiagramEditorInputProvider)viewer).getDiagramEditorInput();
			return isInherited(input);
		}
		return false;
	}
	
	private static boolean isInherited(DiagramEditorInput input) {
		return input != null && input.getWrapper() != null
				&& input.getWrapper().isInherited();
	}
	
	private static Collection getSemanticChildren(DiagramEditPart editPart) {
		EditPartViewer viewer = editPart.getViewer();
		if(viewer instanceof IDiagramEditorInputProvider) {
			DiagramEditorInput input = ((IDiagramEditorInputProvider)viewer).getDiagramEditorInput();
			if(input != null && input.getWrapper() != null &&
					input.getWrapper().isInherited()) {
				Object model = editPart.getModel();
				if(model instanceof View) {
					Collection children = null;
					Diagram diagram = editPart.getDiagramView();
					String type = diagram.getType();
					if(DiagramManager.AD_kind.equals(type)) {
						DiagramAdapter da = ((DiagramAdapter)BridgeHelper.getNodeAdapter(diagram.getElement()));
						if(da != null) {
							BreakdownElementWrapperItemProvider wrapper = input.getWrapper();
							if(TngUtil.getBestAdapterFactory(wrapper.getAdapterFactory()) != TngAdapterFactory.INSTANCE.getWBS_ComposedAdapterFactory()) {
								List wrappers = ProcessUtil.getWrappers(wrapper, new AdapterFactory[] {
										TngAdapterFactory.INSTANCE.getWBS_ComposedAdapterFactory()});
								wrapper = (BreakdownElementWrapperItemProvider) wrappers.get(0);
							}
							ActivityDiagramAdapter adapter = null;
							try {
								adapter = new ActivityDiagramAdapter(wrapper);
								adapter.setFilter(da.getFilter());
								adapter.setSuppression(Suppression.getSuppression(TngUtil.getOwningProcess(wrapper)));
								children = adapter.getChildren();
							}
							finally {
								if(adapter != null) {
									adapter.dispose();
								}
							}
						}
					}
					else if(DiagramManager.ADD_kind.equals(type) || DiagramManager.WPD_kind.equals(type)) {
						DiagramImpl d;
						if(DiagramManager.ADD_kind.equals(type)) {
							d = (DiagramImpl) ModelFactory.eINSTANCE.createActivityDetailDiagram();
						}
						else {
							d = (DiagramImpl) ModelFactory.eINSTANCE.createWorkProductDependencyDiagram();
						}						
						DiagramImpl diagramInUse = ((DiagramImpl)diagram.getElement());
						Suppression suppression = diagramInUse.getSuppression();
						if(suppression != null) {
							d.setWrapper(input.getWrapper());
							d.setFilter(diagramInUse.getFilter());
							d.setSuppression(diagramInUse.getSuppression());
							children = d.getChildren();
						}
					}
					return children;
				}
			}
		}
		return null;
	}
	
	public static void refreshConnections(DiagramEditPart editPart) {
		Diagram diagram = editPart.getDiagramView();
		for (Iterator iter = diagram.getEdges().iterator(); iter.hasNext();) {
			Edge edge = (Edge) iter.next();
			boolean visible = edge.getSource() != null && edge.getSource().isVisible()
				&& edge.getTarget() != null && edge.getTarget().isVisible();
			if(edge.isVisible() != visible) {
				edge.setVisible(visible);
			}
		};
		
	}
	
	private static void refreshChildren(DiagramEditPart editPart) {
		Collection semanticChildren = getSemanticChildren(editPart);
		if(semanticChildren != null) {
			refreshChildren(editPart, semanticChildren);
			refreshConnections(editPart);
		}
	}
	
	
	public static void filterChildren(EditPart editPart, Collection children) {
		DiagramEditPart diagramEditPart = DiagramCoreUtil.getDiagramEditPart(editPart);
		Collection semanticChildren = getSemanticChildren(diagramEditPart);
		if(semanticChildren == null) {
			children.clear();
		}
		else {
			for (Iterator iter = children.iterator(); iter.hasNext();) {
				 EObject child = (EObject) iter.next();
				 MethodElement e = BridgeHelper.getMethodElement(child);
				 if(getWrapper(e, semanticChildren) == null) {
					 iter.remove();
				 }
			}
		}
	}
	
	private static Object getWrapper(MethodElement e, Collection semanticChildren) {
		for (Iterator iterator = semanticChildren.iterator(); iterator.hasNext();) {
			Object c = (Object) iterator.next();
			if(TngUtil.unwrap(c) == e) {
				return c;
			}
		}
		return null;
	}
	
	/**
	 * Refreshes edit part of an inherited element.
	 * 
	 * @param editPart
	 */
	private static void refreshChildren(EditPart editPart, Collection semanticChildren) {		
		// special handling for edit part of RoleTaskComposite that should not be shown if
		// none of its tasks are visible
		//
		boolean isRoleTaskComposite = false;
		boolean hasTask = false;
		Object model = editPart.getModel();
		if(model instanceof View && ((View)model).getElement() instanceof RoleTaskComposite) {
			isRoleTaskComposite = true;
		}
		
		for (Iterator<?> iter = editPart.getChildren().iterator(); iter
		.hasNext();) {
			Object child = (Object) iter.next();
			if(child instanceof EditPart) {
				boolean refreshChildren = true;
				EditPart childEditPart = ((EditPart)child);
				Object m = childEditPart.getModel();
				if(m instanceof View) {
					View v = (View) m;
					MethodElement e = BridgeHelper.getMethodElement(v);
					if(e != null) {
						Object object = getWrapper(e, semanticChildren);
						boolean visible = object != null;
						if(v.isVisible() != visible) {
							v.setVisible(visible);
						}
						if(!visible) {
							refreshChildren = false;
						}
						else if(isRoleTaskComposite && !hasTask && e instanceof TaskDescriptor) {
							hasTask = true;
						}
					}
					else {
						// this is a non-UMA node like control node, text node, figure...
						// 
					}
				}
				if(refreshChildren) {
					refreshChildren(childEditPart, semanticChildren);
				}
			}
		}
		
		if(isRoleTaskComposite && !hasTask) {
			((View)editPart.getModel()).setVisible(false);
		}
	}
	
	public static void doRefresh(final DiagramEditPart editPart, IProgressMonitor monitor, final boolean refreshData) {
		final boolean isInherited = isInherited(editPart);
		final Diagram diagram = (Diagram) editPart.getModel();
		if(diagram.getElement() instanceof org.eclipse.epf.diagram.model.Diagram) {
			TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(diagram);
			AbstractEMFOperation op = new AbstractEMFOperation(domain, StringStatics.BLANK) {
				@Override
				protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info)
				throws ExecutionException {
					if(refreshData) {
						// refresh the data
						//
						org.eclipse.epf.diagram.model.Diagram d = (org.eclipse.epf.diagram.model.Diagram) diagram.getElement();
						d.setObject(d.getLinkedElement());
					}
					
					// show/hide nodes according updated data
					//
					if(isInherited) {
						refreshChildren(editPart);
					}
					else {
						updateEdges(diagram);
						updateView(diagram);
					}
					
					return Status.OK_STATUS;
				}	

			};
			try {
				op.execute(monitor, null);				
			} catch (ExecutionException e) {
				CommonPlugin.getDefault().getLogger().logError(e);
			}		
		}
		else {
			NodeAdapter adapter = BridgeHelper.getNodeAdapter(diagram.getElement());
			if(adapter instanceof DiagramAdapter) {
				if(refreshData) {
					((DiagramAdapter)adapter).populateDiagram();
				}
				if(isInherited) {
					try {
						new AbstractEMFOperation(TransactionUtil.getEditingDomain(diagram), StringStatics.BLANK) {

							@Override
							protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
								refreshChildren(editPart);
								return Status.OK_STATUS;
							}
							
						}.execute(monitor, null);
					} catch (ExecutionException e) {
						DiagramCorePlugin.getDefault().getLogger().logError(e);
					}
				}
			}
		}
	}
	
	public static void refresh(final DiagramEditPart editPart, IProgressMonitor monitor) {
		IDiagramEditorInputProvider p = ((IDiagramEditorInputProvider)editPart.getViewer()); 
		boolean wasDirty = p.getEditor() != null ? p.getEditor().isDirty() : false;
		boolean wasBaseDirty = false;
		IEditorPart baseEditor = null;
		final boolean isInherited = isInherited(editPart);
		if(isInherited) {
			MethodElement element = BridgeHelper.getMethodElement(editPart.getDiagramView());
			String type = editPart.getDiagramView().getType();
			
			if(p.getEditor() != null) {
				// try to find the dirty flag of base diagram editor
				//
				IEditorReference[] editorRefs = p.getEditor().getSite().getPage().getEditorReferences();
				for (int i = 0; i < editorRefs.length; i++) {
					IEditorReference ref = editorRefs[i];
					try {
						if(ref.getEditorInput() instanceof IDiagramFileEditorInputProxy) {
							DiagramEditorInput input = ((IDiagramFileEditorInputProxy)ref.getEditorInput()).getDiagramEditorInput();
							if(input.getWrapper() == null && input.getMethodElement() == element &&
									DiagramManager.getDiagramType(type) == input.getDiagramType()) {
								IEditorPart editor = ref.getEditor(false);
								if(editor != null) {
									wasBaseDirty = editor.isDirty();
									baseEditor = editor;
									break;
								}
							}
						}
					} catch (PartInitException e) {
						DiagramCorePlugin.getDefault().getLogger().logError(e);
					}
				}
			}
		}
		
		doRefresh(editPart, monitor, true);
		
		// editors can become dirty after refresh
		// clear dirty flag
		//
		if(!wasDirty && p.getEditor() != null && p.getEditor().isDirty()) {
			((SharedResourceDiagramDocumentProvider)((DiagramDocumentEditor)p.getEditor()).getDocumentProvider())
				.markDocumentAsSaved((IFileEditorInput) p.getEditor().getEditorInput());
		}
		if(baseEditor != null && !wasBaseDirty) {
			((SharedResourceDiagramDocumentProvider)((DiagramDocumentEditor)baseEditor).getDocumentProvider())
				.markDocumentAsSaved((IFileEditorInput) baseEditor.getEditorInput());
		}
	}
	
	public static void refresh(final DiagramEditPart editPart, IProgressMonitor monitor, boolean isinherited){
		
		final boolean isInherited = isInherited(editPart);
		final Diagram diagram = (Diagram) editPart.getModel();
		if(diagram.getElement() instanceof org.eclipse.epf.diagram.model.Diagram) {
			try {
				TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(diagram);
				TxUtil.runInTransaction(diagram.getElement(), new Runnable() {

					public void run() {
						// refresh the data
						//
						org.eclipse.epf.diagram.model.Diagram d = (org.eclipse.epf.diagram.model.Diagram) diagram.getElement();
						d.setObject(d.getLinkedElement());
					}
					
				});
				
				TxUtil.runInTransaction(domain, new Runnable() {

					public void run() {
						// show/hide nodes according updated data
						//
						if(isInherited) {
							refreshChildren(editPart);
						}
						else {
							updateEdges(diagram);
							updateView(diagram);
						}
					}
					
				});
			} catch (Exception e) {
				DiagramCorePlugin.getDefault().getLogger().logError(e);
			}
		}
		else {
			NodeAdapter adapter = BridgeHelper.getNodeAdapter(diagram.getElement());
			if(adapter instanceof DiagramAdapter) {
				((DiagramAdapter)adapter).populateDiagram();
				if(isInherited) {
					try {
						new AbstractEMFOperation(TransactionUtil.getEditingDomain(diagram), StringStatics.BLANK) {

							@Override
							protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
								refreshChildren(editPart);
								return Status.OK_STATUS;
							}
							
						}.execute(monitor, null);
					} catch (ExecutionException e) {
						DiagramCorePlugin.getDefault().getLogger().logError(e);
					}
				}
			}
		}
	}
	
	public static void resetEditor(AbstractDiagramEditor editor){
		if(editor.isEditable()){
			DiagramEditPart editPart =editor.getDiagramEditPart();
			IEditorInput input = editor.getEditorInput();
			if(input instanceof DiagramEditorInputProxy ){
				initialize(editPart, (DiagramEditorInputProxy)input, 
						new NullProgressMonitor());
			}
		}
	}
	
	public static boolean isModifiable(Object element) {
		if(element instanceof DiagramFileEditorInputProxy){
				DiagramFileEditorInputProxy input = (DiagramFileEditorInputProxy)element;
				if(input != null){
					DiagramEditorInput dInput = input.getDiagramEditorInput();
					if(dInput != null){
						MethodElement e = dInput.getMethodElement();
						// Check for plugin lock.
						if(e != null){
							if(TngUtil.isLocked(e)) 
								return false;
						}
						// Check wrapper is readonly.
						Object wrapper = dInput.getWrapper();
						if(wrapper != null && ((BreakdownElementWrapperItemProvider)wrapper).isReadOnly()){
							return false;
						}
					}
				}
			}
		return true;
	}
	
	/**
	 * GMF and GEF is not handling connections visibility properly. 
	 * This is work-around solution to handle connections visibility.  
	 * Visibility of edges need to set first and then nodes. 
	 * defect opened for this: 
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=184081
	 */
	public static void refreshConnectionEditParts(DiagramEditPart diagramEditPart) {

		GraphicalViewer viewer = (GraphicalViewer)diagramEditPart.getViewer();
		Diagram act = (Diagram)diagramEditPart.getModel();
		List edges = act.getEdges();
		for (Iterator iter = edges.iterator(); iter.hasNext();) {
			Edge edge = (Edge) iter.next();
			if(edge.isVisible()){
				ConnectionEditPart part = (ConnectionEditPart)viewer.getEditPartRegistry().get(edge); 
					
				if(part != null){
					if(part.getSource() == null){
						for (Iterator iter1 = diagramEditPart.getChildren().iterator(); iter1.hasNext();) {
							EditPart element = (EditPart) iter1.next();
							Object model = element.getModel();
							if(edge.getSource() == model){
								if(element instanceof GraphicalEditPart){
									if(((GraphicalEditPart)element).getFigure().isVisible()){
										part.setSource(element);
									}else{
										part.setSource(null);
									}
								}
							}
						}
					}
					if(part.getTarget() == null){
						for (Iterator iter1 = diagramEditPart.getChildren().iterator(); iter1.hasNext();) {
							EditPart element = (EditPart) iter1.next();
							Object model = element.getModel();
							if(edge.getTarget() == model){
								if(element instanceof GraphicalEditPart){
									if(((GraphicalEditPart)element).getFigure().isVisible()){
										part.setTarget(element);
									}else{
										part.setTarget(null);
									}
								}
							}
						}
					}
				}
			}
		}
		
		try{
		for (Iterator iter = edges.iterator(); iter.hasNext();) {
			Edge edge = (Edge) iter.next();
				org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionEditPart part = 
					(org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionEditPart)viewer.getEditPartRegistry().get(edge); 
				if(part != null && (part.getSource() == null || part.getTarget() == null)
						&& part.getFigure() != null){
					part.getFigure().setVisible(false);
				    part.getFigure().revalidate();
					part.deactivate();
				}
		}
		}catch(Exception e){
			if(DiagramCorePlugin.getDefault().isDebugging()){
				DiagramCorePlugin.getDefault().getLogger().logError("Error occured while refresh the connection: "+ e); //$NON-NLS-1$
				e.printStackTrace();
			}
		}
	}
}