| //------------------------------------------------------------------------------ |
| // 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.library.ui.util; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.epf.common.ui.util.MsgBox; |
| import org.eclipse.epf.common.utils.StrUtil; |
| import org.eclipse.epf.library.LibraryResources; |
| import org.eclipse.epf.library.LibraryServiceUtil; |
| import org.eclipse.epf.library.edit.LibraryEditPlugin; |
| import org.eclipse.epf.library.edit.LibraryEditResources; |
| import org.eclipse.epf.library.edit.command.DeleteMethodElementCommand; |
| import org.eclipse.epf.library.edit.ui.UserInteractionHelper; |
| import org.eclipse.epf.library.edit.util.IRunnableWithProgress; |
| 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.LibraryUIPlugin; |
| import org.eclipse.epf.services.ILibraryPersister; |
| import org.eclipse.epf.uma.ContentElement; |
| import org.eclipse.epf.uma.Guidance; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.UmaFactory; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.util.ContentDescriptionFactory; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.viewers.ArrayContentProvider; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.ListDialog; |
| |
| /** |
| * class to convert guidance types |
| * |
| * @author ??? |
| * @sicne 1.0 |
| * |
| */ |
| public class ConvertGuidanceType { |
| |
| static IValidator validator; |
| private static int[] compatibleGuidances = { UmaPackage.CONCEPT, |
| // UmaPackage.CHECKLIST, |
| // UmaPackage.EXAMPLE, |
| UmaPackage.GUIDELINE, |
| // UmaPackage.ESTIMATE, |
| // UmaPackage.ESTIMATING_METRIC, |
| // UmaPackage.ESTIMATION_CONSIDERATIONS, |
| // UmaPackage.REPORT, |
| // UmaPackage.TEMPLATE, |
| UmaPackage.SUPPORTING_MATERIAL, |
| // UmaPackage.TOOL_MENTOR, |
| // UmaPackage.WHITEPAPER, |
| // UmaPackage.TERM_DEFINITION, |
| // UmaPackage.PRACTICE, |
| // UmaPackage.REUSABLE_ASSET |
| }; |
| |
| private static List compatibleGuidancesList = new ArrayList(); |
| static { |
| for (int i = 0; i < compatibleGuidances.length; i++) |
| compatibleGuidancesList.add(new Integer(compatibleGuidances[i])); |
| } |
| |
| public static Guidance convertGuidance(Guidance oldGuidance, Shell shell, |
| DeleteMethodElementCommand command) { |
| return convertGuidance(oldGuidance, shell, command, null); |
| } |
| |
| public static Guidance convertGuidance(final Guidance oldGuidance, Shell shell, |
| DeleteMethodElementCommand command, EClass newType) { |
| if (newType == null) { |
| if (shell == null) { |
| shell = PlatformUI.getWorkbench().getDisplay().getActiveShell(); |
| } |
| ListDialog dlg = new ListDialog(shell); |
| dlg.setHeightInChars(5); |
| dlg.setContentProvider(new ArrayContentProvider()); |
| dlg.setLabelProvider(new LabelProvider() { |
| public String getText(Object element) { |
| switch (((Integer) element).intValue()) { |
| // TODO: refactor these strings (and this whole dialog) into |
| // library.ui |
| case UmaPackage.CONCEPT: |
| return LibraryResources.concept_text; |
| case UmaPackage.CHECKLIST: |
| return LibraryResources.checklist_text; |
| case UmaPackage.EXAMPLE: |
| return LibraryResources.example_text; |
| case UmaPackage.GUIDELINE: |
| return LibraryResources.guideline_text; |
| case UmaPackage.ESTIMATION_CONSIDERATIONS: |
| return LibraryResources.estimationConsiderations_text; |
| case UmaPackage.REPORT: |
| return LibraryResources.report_text; |
| case UmaPackage.TEMPLATE: |
| return LibraryResources.template_text; |
| case UmaPackage.SUPPORTING_MATERIAL: |
| return LibraryResources.supportingMaterial_text; |
| case UmaPackage.TOOL_MENTOR: |
| return LibraryResources.toolMentor_text; |
| case UmaPackage.WHITEPAPER: |
| return LibraryResources.whitepaper_text; |
| case UmaPackage.TERM_DEFINITION: |
| return LibraryResources.termDefinition_text; |
| case UmaPackage.PRACTICE: |
| return LibraryResources.practice_text; |
| case UmaPackage.REUSABLE_ASSET: |
| return LibraryResources.reusableAsset_text; |
| default: |
| return LibraryResources.unknownGuidance_text; |
| } |
| |
| } |
| }); |
| List newGuidanceTypeList = getValidNewGuidanceTypes(oldGuidance); |
| if (newGuidanceTypeList == null) { |
| LibraryUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| LibraryResources.convertGuidanceError_title, |
| LibraryResources.unsupportedGuidanceTypeError_msg, |
| NLS.bind(LibraryResources.unsupportedGuidanceTypeError_reason, StrUtil.toLower(TngUtil.getTypeText(oldGuidance)))); |
| return null; |
| } |
| dlg.setInput(newGuidanceTypeList); |
| dlg.setTitle(LibraryResources.convertGuidanceDialog_title); |
| dlg.setMessage(LibraryResources.convertGuidanceDialog_text); |
| if (dlg.open() == Dialog.CANCEL) |
| return null; |
| |
| Object[] selectionResult = dlg.getResult(); |
| if (selectionResult == null) |
| return null; |
| int chosenGuidance = ((Integer) selectionResult[0]).intValue(); |
| |
| // Guidance newGuidance = doConvert(oldGuidance, chosenGuidance, command); |
| |
| newType = getGuidanceType(chosenGuidance); |
| } |
| |
| if(newType == null) { |
| return null; |
| } |
| final EClass finalNewType = newType; |
| final TypeConverter.TypeConversionCommand[] cmdHolder = new TypeConverter.TypeConversionCommand[1]; |
| try { |
| final MultiStatus multiStatus = new MultiStatus( |
| LibraryEditPlugin.INSTANCE.getSymbolicName(), 0, "", null); //$NON-NLS-1$ |
| UserInteractionHelper.getUIHelper().runWithProgress(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, InterruptedException { |
| TypeConverter.TypeConversionCommand cmd = TypeConverter.createTypeConversionCommand(oldGuidance, finalNewType, null, null, true, true); |
| cmdHolder[0] = cmd; |
| if(!cmd.getIllegalReferencers().isEmpty()) { |
| // type conversion will remove some illegal references |
| // confirm with user before continue |
| // |
| for (Iterator iter = cmd.getIllegalReferencers().iterator(); iter.hasNext();) { |
| MethodElement e = (MethodElement) iter.next(); |
| // don't show predefined element |
| // |
| if(!TngUtil.isPredefined(e)) { |
| String msg = NLS.bind(LibraryEditResources.elementType_text, e.eClass().getName(), TngUtil.getLabelWithPath(e)); |
| IStatus status = new Status(IStatus.INFO, |
| LibraryEditPlugin.INSTANCE.getSymbolicName(), 0, msg, |
| null); |
| multiStatus.add(status); |
| } |
| } |
| } |
| } |
| |
| }, false, "Looking for invalid references..."); |
| if (multiStatus.getChildren().length > 0 && |
| LibraryUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayConfirmation( |
| LibraryResources.convertGuidanceDialog_title, |
| LibraryEditResources.confirm_remove_references_text, |
| multiStatus) == Dialog.CANCEL) { |
| return null; |
| } |
| final TypeConverter.TypeConversionCommand cmd = cmdHolder[0]; |
| if(cmd == null) { |
| return null; |
| } |
| IStatus status = UserInteractionHelper.checkModify(cmd.getModifiedResources(), shell); |
| if(!status.isOK()) { |
| LibraryUIPlugin.getDefault().getMsgDialog().display(LibraryResources.convertGuidanceDialog_title, status); |
| return null; |
| } |
| UserInteractionHelper.getUIHelper().runWithProgress(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, InterruptedException { |
| cmd.execute(); |
| } |
| |
| }, false, "Performing type change..."); |
| final Guidance newGuidance = (Guidance) cmd.getResult().iterator().next(); |
| final Exception[] exceptionHolder = new Exception[1]; |
| Exception busyCursorWhileException = null; |
| // save modified resources |
| // |
| try { |
| PlatformUI.getWorkbench().getProgressService().busyCursorWhile(new org.eclipse.jface.operation.IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, InterruptedException { |
| monitor.beginTask("Saving changes", IProgressMonitor.UNKNOWN); |
| ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil.getCurrentPersister().getFailSafePersister(); |
| try { |
| for (Iterator iter = cmd.getModifiedResources().iterator(); iter.hasNext();) { |
| Resource resource = (Resource) iter.next(); |
| resource.setModified(true); |
| monitor.subTask("Saving " + resource.getURI().toFileString()); |
| persister.save(resource); |
| } |
| monitor.subTask("Commiting saves"); |
| persister.commit(); |
| |
| if(ContentDescriptionFactory.hasPresentation(newGuidance)) { |
| Resource resource = newGuidance.getPresentation().eResource(); |
| monitor.subTask("Moving " + resource.getURI().toFileString() + " to right location"); |
| persister.adjustLocation(resource); |
| } |
| monitor.subTask("Copying resources"); |
| cmd.copyResources(); |
| |
| } catch (Exception e) { |
| persister.rollback(); |
| exceptionHolder[0] = e; |
| } |
| } |
| |
| }); |
| } catch (InvocationTargetException e) { |
| busyCursorWhileException = e; |
| } catch (InterruptedException e) { |
| busyCursorWhileException = e; |
| } |
| // UserInteractionHelper.getUIHelper().runWithProgress(new IRunnableWithProgress() { |
| // |
| // public void run(IProgressMonitor monitor) |
| // throws InvocationTargetException, InterruptedException { |
| // monitor.beginTask("Saving changes", IProgressMonitor.UNKNOWN); |
| // ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil.getCurrentPersister().getFailSafePersister(); |
| // try { |
| // for (Iterator iter = cmd.getModifiedResources().iterator(); iter.hasNext();) { |
| // Resource resource = (Resource) iter.next(); |
| // resource.setModified(true); |
| // monitor.subTask("Saving " + resource.getURI().toFileString()); |
| // persister.save(resource); |
| // } |
| // monitor.subTask("Commiting saves"); |
| // persister.commit(); |
| // |
| // if(ContentDescriptionFactory.hasPresentation(newGuidance)) { |
| // Resource resource = newGuidance.getPresentation().eResource(); |
| // monitor.subTask("Moving " + resource.getURI().toFileString() + " to right location"); |
| // persister.adjustLocation(resource); |
| // } |
| // monitor.subTask("Copying resources"); |
| // cmd.copyResources(); |
| // |
| // } catch (Exception e) { |
| // persister.rollback(); |
| // exceptionHolder[0] = e; |
| // } |
| // } |
| // |
| // }, false, "Saving changes..."); |
| Exception exception = busyCursorWhileException != null ? busyCursorWhileException : exceptionHolder[0]; |
| if(exception != null) { |
| LibraryUIPlugin.getDefault().getMsgDialog().displayError( |
| LibraryResources.convertGuidanceError_title, |
| NLS.bind(LibraryResources.saveConvertedGuidanceError_msg, |
| newGuidance.getName()), |
| LibraryResources.error_reason, exception); |
| |
| } |
| |
| return newGuidance; |
| } |
| finally { |
| if(cmdHolder[0] != null) { |
| try { cmdHolder[0].dispose(); } catch(Exception e) {} |
| } |
| } |
| } |
| |
| /** |
| * @param oldGuidance |
| * @param newGuidance |
| * @return |
| */ |
| private static String checkName(Guidance oldGuidance, Guidance newGuidance) { |
| // TODO Auto-generated method stub |
| |
| |
| validator = new ContentElementNameValidator(oldGuidance.eContainer() |
| , UmaPackage.eINSTANCE.getContentPackage_ContentElements(), |
| (ContentElement) newGuidance, new ValidatorFactory.TypeFilter(newGuidance)); |
| |
| String msg = validator.isValid(newGuidance.getName()); |
| |
| if (msg != null) { |
| String featureTxt = TngUtil.getFeatureText(UmaPackage.eINSTANCE |
| .getNamedElement_Name()); |
| String title = LibraryEditResources.resolveNameConflictDialog_title; |
| String dlgMsg = NLS.bind( |
| LibraryEditResources.resolveNameConflictDialog_text, |
| StrUtil.toLower(featureTxt), newGuidance.getName()); |
| String currentValue = (String) newGuidance.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; |
| } |
| |
| private static EClass getGuidanceType(int newGuidanceType) { |
| switch (newGuidanceType) { |
| case UmaPackage.CONCEPT: |
| return UmaPackage.Literals.CONCEPT; |
| case UmaPackage.CHECKLIST: |
| return UmaPackage.Literals.CHECKLIST; |
| case UmaPackage.EXAMPLE: |
| return UmaPackage.Literals.EXAMPLE; |
| case UmaPackage.GUIDELINE: |
| return UmaPackage.Literals.GUIDELINE; |
| case UmaPackage.ESTIMATION_CONSIDERATIONS: |
| return UmaPackage.Literals.ESTIMATION_CONSIDERATIONS; |
| case UmaPackage.REPORT: |
| return UmaPackage.Literals.REPORT; |
| case UmaPackage.TEMPLATE: |
| return UmaPackage.Literals.TEMPLATE; |
| case UmaPackage.SUPPORTING_MATERIAL: |
| return UmaPackage.Literals.SUPPORTING_MATERIAL; |
| case UmaPackage.TOOL_MENTOR: |
| return UmaPackage.Literals.TOOL_MENTOR; |
| case UmaPackage.WHITEPAPER: |
| return UmaPackage.Literals.WHITEPAPER; |
| case UmaPackage.TERM_DEFINITION: |
| return UmaPackage.Literals.TERM_DEFINITION; |
| case UmaPackage.PRACTICE: |
| return UmaPackage.Literals.PRACTICE; |
| case UmaPackage.REUSABLE_ASSET: |
| return UmaPackage.Literals.REUSABLE_ASSET; |
| default: |
| return null; |
| } |
| } |
| |
| private static Guidance createNewGuidance(int newGuidanceType) { |
| switch (newGuidanceType) { |
| case UmaPackage.CONCEPT: |
| return UmaFactory.eINSTANCE.createConcept(); |
| case UmaPackage.CHECKLIST: |
| return UmaFactory.eINSTANCE.createChecklist(); |
| case UmaPackage.EXAMPLE: |
| return UmaFactory.eINSTANCE.createExample(); |
| case UmaPackage.GUIDELINE: |
| return UmaFactory.eINSTANCE.createGuideline(); |
| case UmaPackage.ESTIMATION_CONSIDERATIONS: |
| return UmaFactory.eINSTANCE.createEstimationConsiderations(); |
| case UmaPackage.REPORT: |
| return UmaFactory.eINSTANCE.createReport(); |
| case UmaPackage.TEMPLATE: |
| return UmaFactory.eINSTANCE.createTemplate(); |
| case UmaPackage.SUPPORTING_MATERIAL: |
| return UmaFactory.eINSTANCE.createSupportingMaterial(); |
| case UmaPackage.TOOL_MENTOR: |
| return UmaFactory.eINSTANCE.createToolMentor(); |
| case UmaPackage.WHITEPAPER: |
| return UmaFactory.eINSTANCE.createWhitepaper(); |
| case UmaPackage.TERM_DEFINITION: |
| return UmaFactory.eINSTANCE.createTermDefinition(); |
| case UmaPackage.PRACTICE: |
| return UmaFactory.eINSTANCE.createPractice(); |
| case UmaPackage.REUSABLE_ASSET: |
| return UmaFactory.eINSTANCE.createReusableAsset(); |
| default: |
| return null; |
| } |
| } |
| |
| public static List getValidNewGuidanceTypes(Guidance oldGuidance) { |
| if (oldGuidance == null) |
| return null; |
| Integer oldGuidanceClassID = new Integer(oldGuidance.eClass() |
| .getClassifierID()); |
| if (!compatibleGuidancesList.contains(oldGuidanceClassID)) |
| return null; |
| List guidanceList = new ArrayList(); |
| for (int i = 0; i < compatibleGuidances.length; i++) { |
| Integer compatibleGuidanceTypeClassID = new Integer( |
| compatibleGuidances[i]); |
| if (!oldGuidanceClassID.equals(compatibleGuidanceTypeClassID)) |
| guidanceList.add(compatibleGuidanceTypeClassID); |
| } |
| return guidanceList; |
| } |
| |
| } |
