| //------------------------------------------------------------------------------ |
| // 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.HashSet; |
| 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.editparts.InternalNodeEditPart; |
| 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(); |
| boolean dirty = editor.isDirty(); |
| try { |
| if(doInitialize(inputProxy, monitor)) { |
| doRefresh(editPart, monitor, false); |
| refreshVisual(editPart); |
| } |
| } catch (CoreException e) { |
| DiagramCorePlugin.getDefault().getLogger().logError(e); |
| } finally { |
| if(editor.isDirty() && !dirty) { |
| // initialization made the document dirty |
| // this will clear dirty flag of the editor |
| // |
| IDocumentProvider docProvider = ((DiagramDocumentEditor)editor).getDocumentProvider(); |
| if (docProvider instanceof SharedResourceDiagramDocumentProvider) { |
| ((SharedResourceDiagramDocumentProvider) docProvider) |
| .markDocumentAsSaved(inputProxy); |
| } |
| } |
| } |
| |
| } |
| } |
| } |
| |
| 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){ |
| GraphicalEditPart sourceEditPart = ((GraphicalEditPart)element); |
| if(sourceEditPart.getFigure().isVisible()){ |
| part.setSource(element); |
| if(sourceEditPart instanceof InternalNodeEditPart && |
| !sourceEditPart.getSourceConnections().contains(part)) { |
| ((InternalNodeEditPart) sourceEditPart).primAddSourceConnection(part, 0); |
| } |
| }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){ |
| GraphicalEditPart targetEditPart = ((GraphicalEditPart)element); |
| if(targetEditPart.getFigure().isVisible()){ |
| part.setTarget(element); |
| if(targetEditPart instanceof InternalNodeEditPart && |
| !targetEditPart.getTargetConnections().contains(part)) { |
| ((InternalNodeEditPart) targetEditPart).primAddTargetConnection(part, 0); |
| } |
| } 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(); |
| } |
| } |
| } |
| } |
