| //------------------------------------------------------------------------------ |
| // 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.io.File; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CompoundCommand; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.InternalEObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.edit.command.RemoveCommand; |
| import org.eclipse.emf.edit.command.SetCommand; |
| 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.LibraryService; |
| import org.eclipse.epf.library.LibraryServiceUtil; |
| import org.eclipse.epf.library.edit.LibraryEditResources; |
| import org.eclipse.epf.library.edit.command.IResourceAwareCommand; |
| import org.eclipse.epf.library.edit.command.NestedCommandExcecutor; |
| import org.eclipse.epf.library.edit.util.ExtensionManager; |
| import org.eclipse.epf.library.edit.util.IOppositeFeatureLoader; |
| import org.eclipse.epf.library.edit.util.Messenger; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.edit.validation.IValidator; |
| import org.eclipse.epf.library.edit.validation.IValidatorFactory; |
| import org.eclipse.epf.library.ui.LibraryUIPlugin; |
| import org.eclipse.epf.library.util.ContentResourceScanner; |
| import org.eclipse.epf.library.util.LibraryUtil; |
| import org.eclipse.epf.library.util.ResourceHelper; |
| import org.eclipse.epf.persistence.util.PersistenceUtil; |
| import org.eclipse.epf.services.ILibraryPersister; |
| import org.eclipse.epf.services.Services; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.BreakdownElementDescription; |
| import org.eclipse.epf.uma.ContentDescription; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.NamedElement; |
| import org.eclipse.epf.uma.UmaFactory; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.util.AssociationHelper; |
| import org.eclipse.epf.uma.util.ContentDescriptionFactory; |
| import org.eclipse.epf.uma.util.UmaUtil; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| |
| /** |
| * @author Phong Nguyen Le |
| * @since 1.0 |
| */ |
| public class TypeConverter { |
| private static final Comparator activityFeatureComparator = new Comparator() { |
| |
| public int compare(Object arg0, Object arg1) { |
| if(arg0 == UmaPackage.Literals.BREAKDOWN_ELEMENT__SUPER_ACTIVITIES) { |
| return -1; |
| } |
| return 0; |
| } |
| |
| }; |
| |
| /** |
| * Converts the specified object to a object of new type specified by <code>newType</code> while still |
| * preserving as many attributes and relationships as possible |
| * |
| * @param object |
| * @param newType |
| * @param oldFeatureToNewFeatureMap map of feature of <code>object</code> to feature of <code>newType</code> |
| * @return new object of type <code>newType</code> |
| */ |
| public static final EObject convert(EObject object, EClass newType, |
| Map oldFeatureToNewFeatureMap, Comparator featureComparator, Set modifiedResources) |
| { |
| TypeConversionCommand cmd = createTypeConversionCommand(object, newType, oldFeatureToNewFeatureMap, featureComparator); |
| Collection<Resource> resources = cmd.getModifiedResources(); |
| if(!resources.isEmpty()) { |
| Resource[] resourceArray = new Resource[resources.size()]; |
| resources.toArray(resourceArray); |
| IStatus status = Services.getAccessController().checkModify(resourceArray, ExtensionManager.getDefaultUserInteractionHandler().getUIContext()); |
| if(!status.isOK()) { |
| Messenger.INSTANCE.showError(LibraryResources.convertActivityError_title, null, status); |
| return null; |
| } |
| } |
| try { |
| cmd.execute(); |
| modifiedResources.addAll(cmd.getModifiedResources()); |
| return (EObject) cmd.getResult().iterator().next(); |
| } |
| finally { |
| cmd.dispose(); |
| } |
| } |
| |
| private static class ResourceCopyTask { |
| ContentResourceScanner scanner; |
| MethodElement owner; |
| String content; |
| String contentPath; |
| |
| /** |
| * @param scanner |
| * @param owner |
| * @param content |
| * @param contentPath |
| */ |
| public ResourceCopyTask(ContentResourceScanner scanner, MethodElement owner, String content, String contentPath) { |
| super(); |
| this.scanner = scanner; |
| this.owner = owner; |
| this.content = content; |
| this.contentPath = contentPath; |
| } |
| |
| } |
| |
| public static class TypeConversionCommand extends CompoundCommand implements IResourceAwareCommand { |
| |
| private Collection<?> result; |
| private EObject object; |
| private HashSet<Resource> modifiedResources; |
| private boolean gotModifiedResources; |
| private List<ResourceCopyTask> resourceCopyTasks; |
| private Resource resource; |
| private Collection illegalReferencers; |
| private NestedCommandExcecutor nestedCommandExcecutor; |
| |
| /** |
| * @param object |
| */ |
| public TypeConversionCommand(EObject object) { |
| this.object = object; |
| modifiedResources = new HashSet<Resource>(); |
| resource = object.eResource(); |
| if(resource != null) { |
| modifiedResources.add(resource); |
| } |
| resourceCopyTasks = new ArrayList<ResourceCopyTask>(); |
| nestedCommandExcecutor = new NestedCommandExcecutor(this); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.emf.common.command.CompoundCommand#dispose() |
| */ |
| public void dispose() { |
| if(illegalReferencers != null) { |
| illegalReferencers.clear(); |
| } |
| if(modifiedResources != null) { |
| modifiedResources.clear(); |
| } |
| if(resourceCopyTasks != null) { |
| resourceCopyTasks.clear(); |
| } |
| if(nestedCommandExcecutor != null) { |
| nestedCommandExcecutor.dispose(); |
| } |
| super.dispose(); |
| } |
| |
| /** |
| * Gets referencers that become illegal after the type conversion |
| * |
| * @return |
| */ |
| public Collection getIllegalReferencers() { |
| if(illegalReferencers == null) { |
| getModifiedResources(); |
| } |
| return illegalReferencers; |
| } |
| |
| public void copyResources() { |
| if(!resourceCopyTasks.isEmpty()) { |
| for (ResourceCopyTask t : resourceCopyTasks) { |
| File newResourcePath = new File(ResourceHelper.getAbsoluteElementResourcePath(t.owner)); |
| t.scanner.setTargetRootPath(newResourcePath); |
| if(t.content != null) { |
| t.scanner.resolveResources(t.owner, t.content, t.contentPath); |
| } |
| else { |
| for (EAttribute attribute : t.owner.eClass().getEAllAttributes()) { |
| Object value = t.owner.eGet(attribute); |
| if(value instanceof String) { |
| t.scanner.resolveResources(t.owner, (String) value, t.contentPath); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.epf.library.edit.command.IResourceAwareCommand#getModifiedResources() |
| */ |
| public Collection<Resource> getModifiedResources() { |
| if(!gotModifiedResources) { |
| illegalReferencers = new HashSet(); |
| for (Iterator iter = commandList.iterator(); iter.hasNext();) { |
| Command cmd = (Command) iter.next(); |
| if(cmd instanceof RemoveCommand) { |
| RemoveCommand removeCommand = (RemoveCommand) cmd; |
| EObject owner = removeCommand.getOwner(); |
| Resource ownerResource = owner.eResource(); |
| if(ownerResource != null && ownerResource != resource) { |
| modifiedResources.add(ownerResource); |
| } |
| if(ownerResource != null && owner != object && !UmaUtil.isContainedBy(owner, object)) { |
| illegalReferencers.add(owner); |
| } |
| } |
| else if(cmd instanceof SetCommand) { |
| SetCommand setCommand = (SetCommand) cmd; |
| EObject owner = setCommand.getOwner(); |
| Resource ownerResource = owner.eResource(); |
| if(ownerResource != null && ownerResource != resource && setCommand.getValue() instanceof EObject) { |
| EObject value = (EObject) setCommand.getValue(); |
| if(value != object || !UmaUtil.isContainedBy(value, object)) { |
| modifiedResources.add(ownerResource); |
| } |
| } |
| if(ownerResource != null && owner != object && !UmaUtil.isContainedBy(owner, object) |
| && setCommand.getValue() == setCommand.getFeature().getDefaultValue()) { |
| illegalReferencers.add(owner); |
| } |
| } |
| } |
| |
| for (Object obj: illegalReferencers) { |
| if (obj instanceof MethodElement) { |
| Resource res = ((MethodElement) obj).eResource(); |
| if (res != null) { |
| modifiedResources.add(res); |
| } |
| } |
| } |
| |
| gotModifiedResources = true; |
| } |
| modifiedResources.addAll(nestedCommandExcecutor.getModifiedResources()); |
| return modifiedResources; |
| } |
| |
| private void setResult(Collection<?> result) { |
| this.result = result; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.emf.common.command.CompoundCommand#getResult() |
| */ |
| public Collection<?> getResult() { |
| return result; |
| } |
| |
| @Override |
| public void execute() { |
| super.execute(); |
| nestedCommandExcecutor.executeNestedCommands(); |
| } |
| |
| @Override |
| public void undo() { |
| nestedCommandExcecutor.undoNestedCommands(); |
| super.undo(); |
| } |
| |
| private List<Command> commandList() { |
| return commandList; |
| } |
| } |
| |
| /** |
| * |
| * @param object EObject |
| * @param newType EClass |
| * @param oldFeatureToNewFeatureMap Map |
| * @param featureComparator Comparator |
| * @return TypeConversionCommand |
| */ |
| public static final TypeConversionCommand createTypeConversionCommand(EObject object, EClass newType, |
| Map oldFeatureToNewFeatureMap, Comparator featureComparator) { |
| return createTypeConversionCommand(object, newType, oldFeatureToNewFeatureMap, featureComparator, false, false); |
| } |
| |
| /** |
| * |
| * @param object EObject |
| * @param newType EClass |
| * @param oldFeatureToNewFeatureMap Map |
| * @param featureComparator Comparator |
| * @param removeIncomingReferences boolean |
| * @param removeVariability boolean |
| * @return TypeConversionCommand |
| */ |
| public static final TypeConversionCommand createTypeConversionCommand(EObject object, EClass newType, |
| Map oldFeatureToNewFeatureMap, Comparator featureComparator, |
| boolean removeIncomingReferences, boolean removeVariability) { |
| TypeConversionCommand cmd = new TypeConversionCommand(object); |
| EObject newObject = prepareConvert(object, newType, oldFeatureToNewFeatureMap, featureComparator, removeIncomingReferences, removeVariability, cmd); |
| |
| // replace object with newObject in the object's container |
| // |
| EObject container = object.eContainer(); |
| if(container != null) { |
| EReference ref = object.eContainmentFeature(); |
| if(ref.isMany()) { |
| List list = (List) container.eGet(ref); |
| int index = list.indexOf(object); |
| cmd.commandList().add(0, new SetCommand(null, container, ref, newObject, index)); |
| } |
| else { |
| cmd.commandList().add(0, new SetCommand(null, container, ref, newObject)); |
| } |
| } |
| |
| cmd.setResult(Collections.singletonList(newObject)); |
| |
| return cmd; |
| } |
| |
| private static ContentResourceScanner createScanner(EObject object) { |
| if(object instanceof ContentDescription && !(object instanceof BreakdownElementDescription)) { |
| File oldResourcePath = new File(ResourceHelper.getFolderAbsolutePath((MethodElement) object)); |
| String rootContentpath = ResourceHelper.getElementPath((MethodElement)object); |
| ContentResourceScanner scanner = new ContentResourceScanner(oldResourcePath, null, rootContentpath, null); |
| return scanner; |
| } |
| return null; |
| } |
| |
| /** |
| * Prepares a compound command to do a type conversion |
| * |
| * @param object |
| * @param newType |
| * @param oldFeatureToNewFeatureMap |
| * @param featureComparator used to sort the feature list of object to convert before copying/moving |
| * feature values to new object. |
| * @param removeIncomingReferences if true will remove all incoming references |
| * @param compoundCommand |
| * @return EObject |
| */ |
| public static final EObject prepareConvert(EObject object, EClass newType, Map oldFeatureToNewFeatureMap, |
| Comparator featureComparator, boolean removeIncomingReferences, boolean removeVariability, |
| TypeConversionCommand compoundCommand) { |
| return prepareConvert(object, newType, oldFeatureToNewFeatureMap, |
| featureComparator, removeIncomingReferences, removeVariability, |
| compoundCommand, 0); |
| } |
| |
| private static final EObject prepareConvert(EObject object, EClass newType, Map oldFeatureToNewFeatureMap, |
| Comparator featureComparator, boolean removeIncomingReferences, boolean removeVariability, |
| TypeConversionCommand compoundCommand, int level) { |
| EObject newObject = UmaFactory.eINSTANCE.create(newType); |
| |
| if(object instanceof MethodElement) { |
| // Handle incoming references. |
| // If removeIncommingReferences is false, redirect all incoming references of object to newObject |
| // If removeIncommingReferences is true, remove all of them. |
| // |
| |
| MethodElement me = (MethodElement) object; |
| Collection oppositeFeatures = me.getOppositeFeatures(); |
| if(!oppositeFeatures.isEmpty()) { |
| |
| // load opposite features |
| // |
| Collection collection = Collections.singletonList(object); |
| for (Iterator iter = ExtensionManager.getOppositeFeatureLoaders().iterator(); iter |
| .hasNext();) { |
| IOppositeFeatureLoader loader = (IOppositeFeatureLoader) iter.next(); |
| loader.loadOppositeFeatures(collection); |
| } |
| |
| if (level == 0) { |
| LibraryUtil.loadAllSkipContents(LibraryService.getInstance().getCurrentMethodLibrary()); |
| } |
| |
| Map referencerToFeatureListMap = AssociationHelper.getReferenceMap(me); |
| for (Iterator iter = referencerToFeatureListMap.entrySet().iterator(); iter |
| .hasNext();) { |
| Map.Entry entry = (Map.Entry) iter.next(); |
| EObject referencer = (EObject) entry.getKey(); |
| for (Iterator iterator = ((Collection)entry.getValue()).iterator(); iterator |
| .hasNext();) { |
| EReference feature = (EReference) iterator.next(); |
| if(!removeIncomingReferences && feature.getEType().isInstance(newObject)) { |
| // new type is compatible, reference can be preserved |
| // |
| if(feature.isMany()) { |
| List list = (List) referencer.eGet(feature); |
| int index = list.indexOf(object); |
| compoundCommand.append(new SetCommand(null, referencer, feature, newObject, index)); |
| } |
| else { |
| compoundCommand.append(new SetCommand(null, referencer, feature, newObject)); |
| } |
| } |
| else { |
| // new type is not compatible, reference must be removed |
| // |
| if(feature.isMany()) { |
| compoundCommand.append(new RemoveCommand(null, referencer, feature, object)); |
| } |
| else { |
| compoundCommand.append(new SetCommand(null, referencer, feature, feature.getDefaultValue())); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // copy all the features |
| // |
| List newObjectFeatures = newType.getEAllStructuralFeatures(); |
| List objectFeatures = new ArrayList(object.eClass().getEAllStructuralFeatures()); |
| if(removeVariability) { |
| objectFeatures.remove(UmaPackage.Literals.VARIABILITY_ELEMENT__VARIABILITY_BASED_ON_ELEMENT); |
| objectFeatures.remove(UmaPackage.Literals.VARIABILITY_ELEMENT__VARIABILITY_TYPE); |
| } |
| if(featureComparator != null) { |
| Collections.sort(objectFeatures, featureComparator); |
| } |
| ContentResourceScanner scanner = createScanner(object); |
| for (Iterator iter = objectFeatures.iterator(); iter.hasNext();) { |
| EStructuralFeature feature = (EStructuralFeature) iter.next(); |
| if(!newObjectFeatures.contains(feature)) { |
| if(oldFeatureToNewFeatureMap != null) { |
| Object f = oldFeatureToNewFeatureMap.get(feature); |
| if(f != null && newObjectFeatures.contains(f)) { |
| feature = (EStructuralFeature) f; |
| } |
| else { |
| feature = null; |
| } |
| } |
| else { |
| feature = null; |
| } |
| } |
| if(feature != null && feature.isChangeable()) { |
| boolean featureHandled = false; |
| if(feature instanceof EReference) { |
| EReference ref = (EReference) feature; |
| if(ref == UmaPackage.Literals.DESCRIBABLE_ELEMENT__PRESENTATION) { |
| if(ContentDescriptionFactory.hasPresentation((MethodElement) object)) { |
| ContentDescription content = (ContentDescription) object.eGet(ref); |
| EClass contentDescType = ContentDescriptionFactory.getContentDescriptionType(newType); |
| if(contentDescType != null && contentDescType != content.eClass()) { |
| EObject newContent = prepareConvert(content, contentDescType, null, null, removeIncomingReferences, removeVariability, compoundCommand, level + 1); |
| |
| // remove old content |
| // |
| EObject container = content.eContainer(); |
| if(container != null) { |
| compoundCommand.append(new SetCommand(null, object, ref, null)); |
| Resource resource = content.eResource(); |
| if(resource != null) { |
| compoundCommand.modifiedResources.add(content.eResource()); |
| } |
| } |
| |
| content = (ContentDescription) newContent; |
| } |
| else { |
| compoundCommand.resourceCopyTasks.add(new ResourceCopyTask(createScanner(content), content, null, "")); //$NON-NLS-1$ |
| } |
| compoundCommand.append(new SetCommand(null, newObject, ref, content)); |
| } |
| featureHandled = true; |
| } |
| else if(!ref.isContainment() && ref.getEOpposite() != null) { |
| // Reference is bi-directional. If opposite reference is a list, replace object |
| // with new object at the same position in the list. |
| // |
| EReference oppositeRef = ref.getEOpposite(); |
| if(oppositeRef.isMany()) { |
| Object value = object.eGet(ref); |
| if(value != null) { |
| if(ref.isMany()) { |
| for (Iterator iterator = ((Collection)value) |
| .iterator(); iterator.hasNext();) { |
| EObject otherEnd = (EObject) iterator.next(); |
| List list = (List) otherEnd.eGet(oppositeRef); |
| int index = list.indexOf(object); |
| compoundCommand.append(new SetCommand(null, otherEnd, oppositeRef, newObject, index)); |
| } |
| } |
| else { |
| EObject otherEnd = (EObject) value; |
| List list = (List) otherEnd.eGet(oppositeRef); |
| int index = list.indexOf(object); |
| compoundCommand.append(new SetCommand(null, otherEnd, oppositeRef, newObject, index)); } |
| } |
| featureHandled = true; |
| } |
| } |
| } |
| if(!featureHandled) { |
| Object value = object.eGet(feature); |
| if (feature == UmaPackage.Literals.NAMED_ELEMENT__NAME) { |
| // validate name |
| String newName = checkName(object, newType); |
| if (newName != null) { |
| value = newName; |
| } |
| } |
| if(scanner != null && value instanceof String && object instanceof MethodElement) { |
| String str = (String) value; |
| if(!StrUtil.isBlank(str)) { |
| compoundCommand.resourceCopyTasks.add(new ResourceCopyTask(scanner, (MethodElement)object, str, "")); //$NON-NLS-1$ |
| } |
| } |
| compoundCommand.append(new SetCommand(null, newObject, feature, value)); |
| } |
| } |
| } |
| |
| return newObject; |
| } |
| |
| /** |
| * Converts an activity to new type. |
| * |
| * @param oldActivity Activity |
| * @param newType EClass |
| * @return Activity |
| */ |
| public static Activity convertActivity(Activity oldActivity, EClass newType) { |
| // activity is already this type |
| // |
| if (newType == oldActivity.eClass()) { |
| return null; |
| } |
| |
| HashSet<Resource> modifiedResources = new HashSet<Resource>(); |
| Activity newActivity = (Activity) TypeConverter.convert(oldActivity, newType, null, activityFeatureComparator, modifiedResources); |
| |
| // make oldActivity a proxy so reference to it can be resolved to newActivity |
| // |
| URI uri = PersistenceUtil.getProxyURI(newActivity); |
| ((InternalEObject)oldActivity).eSetProxyURI(uri); |
| |
| // save modified resources |
| // |
| if (!modifiedResources.isEmpty()) { |
| ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil.getCurrentPersister().getFailSafePersister(); |
| try { |
| for (Resource res : modifiedResources) { |
| persister.save(res); |
| } |
| persister.commit(); |
| |
| } catch (Exception e) { |
| LibraryUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| LibraryResources.convertActivityError_title, |
| NLS |
| .bind( |
| LibraryResources.saveConvertedActivityError_msg, |
| newActivity.getName()), |
| LibraryResources.error_reason, e); |
| |
| persister.rollback(); |
| } |
| } |
| |
| return newActivity; |
| } |
| |
| /** |
| * |
| * @param typeID int |
| * @return EClass |
| */ |
| public static EClass getActivityType(int typeID) { |
| switch (typeID) { |
| case UmaPackage.ACTIVITY: |
| return UmaPackage.Literals.ACTIVITY; |
| case UmaPackage.ITERATION: |
| return UmaPackage.Literals.ITERATION; |
| case UmaPackage.PHASE: |
| return UmaPackage.Literals.PHASE; |
| default: |
| return null; |
| } |
| } |
| |
| |
| /** |
| * @param oldGuidance |
| * @param newGuidance |
| * @return |
| */ |
| private static String checkName(EObject object, EClass newType) { |
| // TODO Auto-generated method stub |
| if (object instanceof NamedElement) { |
| NamedElement e = (NamedElement)object; |
| final IValidator validator = IValidatorFactory.INSTANCE.createNameValidator(e.eContainer(), e, newType); |
| String msg = validator.isValid(e.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), e.getName()); |
| String currentValue = (String) e.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; |
| } |
| |
| } |
