| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 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.authoring.ui.util; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.editors.AbstractDiagramEditor; |
| import org.eclipse.epf.authoring.ui.editors.BreakdownElementEditorInput; |
| import org.eclipse.epf.common.serviceability.MsgBox; |
| import org.eclipse.epf.common.utils.StrUtil; |
| import org.eclipse.epf.library.edit.LibraryEditResources; |
| import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider; |
| import org.eclipse.epf.library.edit.util.MethodElementUtil; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.edit.validation.IValidator; |
| import org.eclipse.epf.library.edit.validation.internal.ContentElementNameValidator; |
| import org.eclipse.epf.library.edit.validation.internal.ValidatorFactory; |
| import org.eclipse.epf.library.ui.LibraryUIText; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.Artifact; |
| import org.eclipse.epf.uma.ContentElement; |
| import org.eclipse.epf.uma.Deliverable; |
| import org.eclipse.epf.uma.Guidance; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.Practice; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.VariabilityElement; |
| import org.eclipse.epf.uma.VariabilityType; |
| import org.eclipse.epf.uma.WorkProduct; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.List; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableItem; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.forms.widgets.FormToolkit; |
| import org.eclipse.ui.forms.widgets.ScrolledForm; |
| |
| |
| /** |
| * @author Shilpa Toraskar |
| * @author Phong Nguyen Le |
| * @since 1.0 |
| */ |
| public class UIHelper { |
| |
| /** |
| * Setting items in a table |
| * |
| * @param table |
| * @param items |
| */ |
| public static void setItems(Table table, ArrayList items) { |
| table.removeAll(); |
| for (int i = 0; i < items.size(); i++) { |
| TableItem item = new TableItem(table, SWT.NONE); |
| item.setText((String) items.get(i)); |
| } |
| } |
| |
| public static List createList(FormToolkit toolkit, Composite parent, |
| int style) { |
| List list = new List(parent, style | SWT.NULL); |
| toolkit.adapt(list, true, true); |
| return list; |
| } |
| |
| /* |
| * Method will return Object[] of guidance excluding Practice. |
| * MethodElementUtil#getSelectedGuidances(EObject) calculates all guidance. |
| */ |
| public static Object[] getSelectedGuidances(ContentElement contentElement) { |
| java.util.List list = MethodElementUtil |
| .getSelectedGuidances(contentElement); |
| for (Iterator it = list.iterator(); it.hasNext();) { |
| Object obj = it.next(); |
| if (obj instanceof Practice) |
| it.remove(); |
| } |
| return list.toArray(); |
| } |
| |
| private static String getFormPageTitlePrefixFor(MethodElement methodElement) { |
| String elementLabel = LibraryUIText.getUIText(methodElement); |
| if (methodElement instanceof WorkProduct) { |
| return LibraryUIText.TEXT_WORK_PRODUCT + " (" + elementLabel + ")"; //$NON-NLS-1$ //$NON-NLS-2$ |
| } else if (methodElement instanceof Guidance) { |
| return LibraryUIText.TEXT_GUIDANCE + " (" + elementLabel + ")"; //$NON-NLS-1$ //$NON-NLS-2$ |
| } else { |
| return elementLabel; |
| } |
| } |
| |
| /** |
| * Sets text for the given form based on the given element, including variable information of the element |
| * if there is any. |
| * |
| * @param form |
| * @param element |
| */ |
| public static void setFormText(ScrolledForm form, MethodElement element) { |
| if (form != null && !form.isDisposed()) { |
| StringBuffer str = new StringBuffer(); |
| str.append(getFormPageTitlePrefixFor(element)); |
| str.append(AuthoringUIResources.editor_title_colon_with_spaces); |
| |
| if(element instanceof VariabilityElement) { |
| str.append(TngUtil.getLabel((VariabilityElement) element, |
| "", true)); //$NON-NLS-1$ |
| } |
| else if(element.getName() != null){ |
| str.append(element.getName()); |
| } |
| form.setText(str.toString()); |
| } |
| } |
| |
| public static boolean checkCircularDeliverables(Deliverable toBePart, |
| Deliverable deliverable) { |
| java.util.List deliverables = toBePart.getDeliveredWorkProducts(); |
| if (deliverables != null && deliverables.size() > 0) { |
| if (deliverables.contains(deliverable)) |
| return false; |
| for (Iterator iterator = deliverables.iterator(); iterator |
| .hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof Deliverable) { |
| return checkCircularDeliverables((Deliverable) obj, |
| deliverable); |
| } |
| } |
| } |
| return true; |
| } |
| |
| public static void deliverablePartsChain(Deliverable e, java.util.List roots) { |
| java.util.List list = e.getDeliveredWorkProducts(); |
| if (list != null && list.size() > 0) { |
| for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof Deliverable) { |
| roots.add(obj); |
| deliverablePartsChain((Deliverable) obj, roots); |
| } |
| } |
| } |
| } |
| |
| public static boolean checkCircularForArtifacts(Artifact destination, |
| Collection sourceElements) { |
| HashSet variantSet = new HashSet(); |
| collectVariantSet(destination, variantSet, VariabilityType.REPLACES_LITERAL); |
| collectVariantSet(destination, variantSet, VariabilityType.EXTENDS_LITERAL); |
| if (! checkCircularForArtifacts1(destination, sourceElements, variantSet)) { |
| return false; |
| } |
| return checkCircularForArtifacts2(destination, sourceElements); |
| } |
| |
| private static boolean checkCircularForArtifacts1(Artifact destination, |
| Collection sourceElements, HashSet variantSet) { |
| if (sourceElements == null) { |
| return true; |
| } |
| for (Iterator iter = sourceElements.iterator(); iter.hasNext();) { |
| Object obj = iter.next(); |
| if(obj instanceof Artifact){ |
| Artifact artifact = (Artifact) obj; |
| if (variantSet.contains(artifact)) { |
| return false; |
| } |
| if (! checkCircularForArtifacts1(destination, artifact.getContainedArtifacts(), variantSet)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| private static boolean checkCircularForArtifacts2(Artifact destination, |
| Collection sourceElements) { |
| for (Iterator iter = sourceElements.iterator(); iter.hasNext();) { |
| Object obj = iter.next(); |
| if (obj instanceof Artifact && sourceIsOrAboveMe((Artifact) obj, destination)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private static boolean sourceIsOrAboveMe(Artifact source, Artifact me) { |
| if (source == me) { |
| return true; |
| } |
| Object obj = me.getContainerArtifact(); |
| if (obj instanceof Artifact && sourceIsOrAboveMe(source, (Artifact) obj)) { |
| return true; |
| } |
| obj = me.getVariabilityBasedOnElement(); |
| if (obj instanceof Artifact && sourceIsOrAboveMe(source, (Artifact) obj)) { |
| return true; |
| } |
| return false; |
| } |
| |
| //Collect all variants of "a" and "a"s ancestror Artifact objects |
| private static void collectVariantSet(Artifact a, HashSet variantSet, VariabilityType type) { |
| while (a != null) { |
| for (Iterator iter = TngUtil.getGeneralizers(a, type); iter.hasNext();) { |
| variantSet.add(iter.next()); |
| } |
| a = a.getContainerArtifact(); |
| } |
| } |
| |
| /** |
| * @param oldGuidance |
| * @param newGuidance |
| * @return |
| */ |
| public static String resolveContentElementNameConflict(EObject container, MethodElement element, EReference |
| reference) { |
| // TODO Auto-generated method stub |
| final IValidator validator = new ContentElementNameValidator(container |
| , reference, |
| (ContentElement) element, new ValidatorFactory.TypeFilter(element)); |
| |
| String msg = validator.isValid(element.getName()); |
| |
| if (msg != null) { |
| String featureTxt = TngUtil.getFeatureText(UmaPackage.eINSTANCE |
| .getNamedElement_Name()); |
| String title = LibraryEditResources.resolveNameConflictDialog_title; //$NON-NLS-1$ |
| String dlgMsg = NLS.bind( |
| LibraryEditResources.resolveNameConflictDialog_text, |
| StrUtil.toLower(featureTxt), element.getName()); |
| String currentValue = (String) element.eGet(UmaPackage.eINSTANCE |
| .getNamedElement_Name()); |
| |
| IInputValidator inputValidator = new IInputValidator() { |
| public String isValid(String newText) { |
| return validator.isValid(newText); |
| } |
| }; |
| |
| InputDialog inputDlg = new InputDialog( |
| MsgBox.getDefaultShell(), title, dlgMsg, currentValue, |
| inputValidator); |
| if (inputDlg.open() == Window.CANCEL) { |
| throw new OperationCanceledException(); |
| } |
| return inputDlg.getValue(); |
| } |
| return null; |
| } |
| /** |
| * Diagram editors of object itself will be closed. And Parent diagram editors |
| * will be refreshed. |
| * |
| */ |
| public static void refreshOpenDiagramEditorsOfParent(Object refreshElement, java.util.List openEditorRefs) { |
| openEditorRefs = new ArrayList(); |
| // Now refresh object's parent's diagrams. |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow() |
| .getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| Object element = null; |
| if (input instanceof BreakdownElementEditorInput) { |
| BreakdownElementEditorInput binput = (BreakdownElementEditorInput)input; |
| if (binput.getWrapper() != null) { |
| element = binput.getWrapper(); |
| if(element instanceof BreakdownElementWrapperItemProvider){ |
| Object parent = ((BreakdownElementWrapperItemProvider)element).getParent(null); |
| if(parent instanceof BreakdownElementWrapperItemProvider){ |
| if(element.equals(refreshElement)) |
| refreshOpenDiagramEditorsOfParent(parent, openEditorRefs); |
| } |
| } |
| } else { |
| element = binput.getMethodElement(); |
| } |
| } |
| if (element != null) |
| { |
| if(element instanceof Activity){ |
| if(((Activity)element).getBreakdownElements().contains(refreshElement)) |
| openEditorRefs.add(reference); |
| else if(refreshElement instanceof BreakdownElementWrapperItemProvider){ |
| Object localRefreshElement = refreshElement; |
| while((localRefreshElement instanceof BreakdownElementWrapperItemProvider) |
| && ((BreakdownElementWrapperItemProvider)localRefreshElement).getOwner()!= null){ |
| if(((BreakdownElementWrapperItemProvider)localRefreshElement).getOwner() |
| .equals(element)){ |
| openEditorRefs.add(reference); |
| } |
| localRefreshElement = ((BreakdownElementWrapperItemProvider)localRefreshElement).getOwner(); |
| } |
| } |
| }else if(element instanceof BreakdownElementWrapperItemProvider){ |
| Collection c = ((BreakdownElementWrapperItemProvider)element).getChildren(element); |
| if(c != null && c.contains(refreshElement)){ |
| openEditorRefs.add(reference); |
| } |
| } |
| |
| } |
| } |
| } |
| int size = openEditorRefs.size(); |
| //IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| IEditorReference reference = (IEditorReference) openEditorRefs.get(i); |
| IEditorPart editor = reference.getEditor(true); |
| if(editor instanceof AbstractDiagramEditor ){ |
| ((AbstractDiagramEditor)editor).refreshDiagram(); |
| } |
| } |
| } |
| |
| public static void closeDiagramEditorsIncludingParent(Object closeElement, java.util.List closeEditorRefs) { |
| closeEditorRefs = new ArrayList(); |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow() |
| .getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| Object element = null; |
| if (input instanceof BreakdownElementEditorInput) { |
| BreakdownElementEditorInput binput = (BreakdownElementEditorInput)input; |
| if (binput.getWrapper() != null) { |
| element = binput.getWrapper(); |
| if(element instanceof BreakdownElementWrapperItemProvider){ |
| Object parent = ((BreakdownElementWrapperItemProvider)element).getParent(null); |
| if(parent instanceof BreakdownElementWrapperItemProvider){ |
| if(element.equals(closeElement)) |
| closeDiagramEditorsIncludingParent(parent, closeEditorRefs); |
| } |
| } |
| } else { |
| element = binput.getMethodElement(); |
| } |
| } |
| if (element != null) |
| { |
| //closeEditorRefs.add(reference); |
| if(element instanceof Activity){ |
| if(element.equals(closeElement)) |
| closeEditorRefs.add(reference); |
| |
| if(((Activity)element).getBreakdownElements().contains(closeElement)) |
| closeEditorRefs.add(reference); |
| else if(closeElement instanceof BreakdownElementWrapperItemProvider){ |
| if(((BreakdownElementWrapperItemProvider)closeElement).getOwner() |
| != null) |
| if(((BreakdownElementWrapperItemProvider)closeElement).getOwner() |
| .equals(element)){ |
| closeEditorRefs.add(reference); |
| if(((BreakdownElementWrapperItemProvider)closeElement).getOwner() |
| instanceof BreakdownElementWrapperItemProvider){ |
| if(((BreakdownElementWrapperItemProvider)((BreakdownElementWrapperItemProvider) |
| closeElement).getOwner()).getOwner().equals(element)) |
| closeEditorRefs.add(reference); |
| } |
| } |
| } |
| }else if(element instanceof BreakdownElementWrapperItemProvider){ |
| Collection c = ((BreakdownElementWrapperItemProvider)element).getChildren(element); |
| if(c != null && c.contains(closeElement)){ |
| closeEditorRefs.add(reference); |
| } |
| } |
| } |
| } |
| } |
| int size = closeEditorRefs.size(); |
| IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| references[i] = (IEditorReference) closeEditorRefs.get(i); |
| } |
| workbenchPage.closeEditors(references, false); |
| } |
| |
| public static VariabilityElement getBaseActivity(Activity activity){ |
| while (!activity.getVariabilityType().equals( |
| VariabilityType.NA_LITERAL)) { |
| |
| VariabilityElement ve = activity |
| .getVariabilityBasedOnElement(); |
| if ((ve != null) && (ve instanceof Activity)) { |
| activity = (Activity) ve; |
| } else { |
| break; |
| } |
| } |
| return activity; |
| } |
| |
| public static void closeDiagramEditors(Object closeElement, java.util.List closeEditorRefs) { |
| closeEditorRefs = new ArrayList(); |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow() |
| .getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| Object element = null; |
| if (input instanceof BreakdownElementEditorInput) { |
| BreakdownElementEditorInput binput = (BreakdownElementEditorInput)input; |
| if (binput.getWrapper() != null) { |
| element = binput.getWrapper(); |
| if(element instanceof BreakdownElementWrapperItemProvider){ |
| Object parent = ((BreakdownElementWrapperItemProvider)element).getParent(element); |
| if(parent instanceof BreakdownElementWrapperItemProvider){ |
| if(element.equals(closeElement)) |
| closeDiagramEditors(parent, closeEditorRefs); |
| } |
| } |
| } else { |
| element = binput.getMethodElement(); |
| } |
| } |
| if (element != null && element.equals(closeElement)) |
| { |
| closeEditorRefs.add(reference); |
| } |
| } |
| } |
| int size = closeEditorRefs.size(); |
| IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| references[i] = (IEditorReference) closeEditorRefs.get(i); |
| } |
| workbenchPage.closeEditors(references, false); |
| references = null; |
| } |
| |
| /** |
| * Diagram editors of object itself will be closed. And Parent diagram editors |
| * will be refreshed. code not tested use refreshOpenDiagramEditors method. |
| */ |
| public static void syncDiagramEditors(Object object) { |
| java.util.List closeEditors = new ArrayList(); |
| java.util.List refreshEditors = new ArrayList(); |
| |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| Object editorElement = null; |
| if (input instanceof BreakdownElementEditorInput) { |
| BreakdownElementEditorInput binput = (BreakdownElementEditorInput)input; |
| if(binput.getWrapper() != null){ |
| editorElement = binput.getWrapper(); |
| }else{ |
| editorElement = binput.getMethodElement(); |
| } |
| } |
| if(editorElement != null){ |
| if(editorElement.equals(object)){ |
| closeEditors.add(reference); |
| }else{ |
| if(editorElement instanceof Activity){ |
| if(((Activity)editorElement).getBreakdownElements().contains(object)) |
| refreshEditors.add(reference); |
| else if(object instanceof BreakdownElementWrapperItemProvider){ |
| Object local = object; |
| while((local instanceof BreakdownElementWrapperItemProvider) |
| && ((BreakdownElementWrapperItemProvider)local).getOwner()!= null){ |
| if(((BreakdownElementWrapperItemProvider)local).getOwner() |
| .equals(editorElement)){ |
| refreshEditors.add(reference); |
| } |
| local = ((BreakdownElementWrapperItemProvider)local).getOwner(); |
| } |
| } |
| }else if(editorElement instanceof BreakdownElementWrapperItemProvider){ |
| Collection c = ((BreakdownElementWrapperItemProvider)editorElement).getChildren(editorElement); |
| if(c != null && c.contains(object)){ |
| refreshEditors.add(reference); |
| } |
| } |
| } |
| } |
| } |
| } |
| // Close editor references and refresh editors. |
| int size = closeEditors.size(); |
| IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| references[i] = (IEditorReference) closeEditors.get(i); |
| } |
| workbenchPage.closeEditors(references, false); |
| references = null; |
| |
| size = refreshEditors.size(); |
| //IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| IEditorReference reference = (IEditorReference) refreshEditors.get(i); |
| IEditorPart editor = reference.getEditor(true); |
| if(editor instanceof AbstractDiagramEditor ){ |
| ((AbstractDiagramEditor)editor).refreshDiagram(); |
| } |
| } |
| |
| } |
| } |
