| /******************************************************************************* |
| * Copyright (c) 2005, 2012 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 API and implementation |
| *******************************************************************************/ |
| package org.eclipse.bpel.ui; |
| |
| import java.text.Collator; |
| import java.util.ArrayList; |
| import java.util.Comparator; |
| import java.util.EventObject; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.TreeSet; |
| import java.util.Vector; |
| |
| import org.eclipse.bpel.common.extension.model.ExtensionMap; |
| import org.eclipse.bpel.common.ui.CommonUIPlugin; |
| import org.eclipse.bpel.common.ui.ICommonUIConstants; |
| import org.eclipse.bpel.common.ui.command.EditModelCommandFramework; |
| import org.eclipse.bpel.common.ui.command.ICommandFramework; |
| import org.eclipse.bpel.common.ui.tray.AdaptingSelectionProvider; |
| import org.eclipse.bpel.common.ui.tray.GraphicalEditorWithPaletteAndTray; |
| import org.eclipse.bpel.common.ui.tray.MultiViewerSelectionProvider; |
| import org.eclipse.bpel.common.ui.tray.TrayComposite; |
| import org.eclipse.bpel.model.Activity; |
| import org.eclipse.bpel.model.Flow; |
| import org.eclipse.bpel.model.Process; |
| import org.eclipse.bpel.ui.actions.AppendNewAction; |
| import org.eclipse.bpel.ui.actions.AutoArrangeFlowsAction; |
| import org.eclipse.bpel.ui.actions.BPELAddChildInTrayAction; |
| import org.eclipse.bpel.ui.actions.BPELCopyAction; |
| import org.eclipse.bpel.ui.actions.BPELCutAction; |
| import org.eclipse.bpel.ui.actions.BPELDeleteAction; |
| import org.eclipse.bpel.ui.actions.BPELDuplicateAction; |
| import org.eclipse.bpel.ui.actions.BPELPasteAction; |
| import org.eclipse.bpel.ui.actions.BPELPrintAction; |
| import org.eclipse.bpel.ui.actions.ChangeTypeAction; |
| import org.eclipse.bpel.ui.actions.InsertNewAction; |
| import org.eclipse.bpel.ui.actions.MakePartner2WayAction; |
| import org.eclipse.bpel.ui.actions.RenameAction; |
| import org.eclipse.bpel.ui.actions.RevertAction; |
| import org.eclipse.bpel.ui.actions.ShowPaletteInPaletteViewAction; |
| import org.eclipse.bpel.ui.actions.ShowPropertiesViewAction; |
| import org.eclipse.bpel.ui.actions.ShowViewAction; |
| import org.eclipse.bpel.ui.actions.ToggleAutoFlowLayout; |
| import org.eclipse.bpel.ui.actions.ToggleLayoutOrientationAction; |
| import org.eclipse.bpel.ui.actions.ToggleShowCompensationHandler; |
| import org.eclipse.bpel.ui.actions.ToggleShowEventHandler; |
| import org.eclipse.bpel.ui.actions.ToggleShowFaultHandler; |
| import org.eclipse.bpel.ui.actions.ToggleShowTerminationHandler; |
| import org.eclipse.bpel.ui.commands.util.ModelAutoUndoRecorder; |
| import org.eclipse.bpel.ui.dnd.BPELTemplateTransferDropTargetListener; |
| import org.eclipse.bpel.ui.dnd.BPELTextTransferDropTargetListener; |
| import org.eclipse.bpel.ui.dnd.FileDropTargetListener; |
| import org.eclipse.bpel.ui.dnd.TextDropTargetListener; |
| import org.eclipse.bpel.ui.editparts.CorrelationSetsEditPart; |
| import org.eclipse.bpel.ui.editparts.FlowEditPart; |
| import org.eclipse.bpel.ui.editparts.MessageExchangesEditPart; |
| import org.eclipse.bpel.ui.editparts.PartnerLinksEditPart; |
| import org.eclipse.bpel.ui.editparts.VariablesEditPart; |
| import org.eclipse.bpel.ui.editparts.util.BPELEditPartFactory; |
| import org.eclipse.bpel.ui.editparts.util.BPELTrayEditPartFactory; |
| import org.eclipse.bpel.ui.factories.AbstractUIObjectFactory; |
| import org.eclipse.bpel.ui.uiextensionmodel.ProcessExtension; |
| import org.eclipse.bpel.ui.util.BPELCreationToolEntry; |
| import org.eclipse.bpel.ui.util.BPELEditModelClient; |
| import org.eclipse.bpel.ui.util.BPELUtil; |
| import org.eclipse.bpel.ui.util.IModelVisitor; |
| import org.eclipse.bpel.ui.util.ModelHelper; |
| import org.eclipse.bpel.ui.util.TransferBuffer; |
| import org.eclipse.bpel.ui.util.WSDLImportHelper; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.Notifier; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.gef.ContextMenuProvider; |
| import org.eclipse.gef.DefaultEditDomain; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.EditPartViewer; |
| import org.eclipse.gef.GraphicalViewer; |
| import org.eclipse.gef.KeyHandler; |
| import org.eclipse.gef.KeyStroke; |
| import org.eclipse.gef.commands.CommandStack; |
| import org.eclipse.gef.dnd.TemplateTransferDragSourceListener; |
| import org.eclipse.gef.palette.PaletteContainer; |
| import org.eclipse.gef.ui.actions.ActionRegistry; |
| import org.eclipse.gef.ui.actions.PrintAction; |
| import org.eclipse.gef.ui.actions.RedoAction; |
| import org.eclipse.gef.ui.actions.SaveAction; |
| import org.eclipse.gef.ui.actions.SelectAllAction; |
| import org.eclipse.gef.ui.actions.UndoAction; |
| import org.eclipse.gef.ui.actions.ZoomInAction; |
| import org.eclipse.gef.ui.actions.ZoomOutAction; |
| import org.eclipse.gef.ui.palette.PaletteViewer; |
| import org.eclipse.gef.ui.palette.PaletteViewerProvider; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.ActionFactory; |
| import org.eclipse.ui.dialogs.SaveAsDialog; |
| import org.eclipse.ui.part.MultiPageEditorSite; |
| import org.eclipse.wst.wsdl.Definition; |
| import org.eclipse.wst.wsdl.internal.impl.DefinitionImpl; |
| import org.eclipse.wst.wsdl.util.WSDLResourceImpl; |
| |
| |
| /** |
| * BPELEditor is the Eclipse editor part for editing BPEL files. |
| */ |
| public class BPELEditor extends GraphicalEditorWithPaletteAndTray /*, IGotoMarker */{ |
| |
| //FIXME can't move it to MultiPageEditor because of chicken and egg problem |
| // TODO: comment |
| protected BPELEditModelClient editModelClient; |
| |
| protected BPELEditorAdapter editorAdapter; |
| |
| // transfer buffer (clipboard) for graph copies |
| private TransferBuffer transferBuffer; |
| |
| protected BPELMultipageEditorPart multipageEditor; |
| |
| // This records all model changes for automatic undo/redo purposes. |
| private ModelAutoUndoRecorder modelAutoUndoRecorder; |
| |
| // Cached key handler used by both the graphical editor and outline view |
| private KeyHandler keyHandler; |
| |
| // Selection listener on the graphical viewer and tray |
| ISelectionChangedListener selectionChangeListener, traySelectionChangeListener; |
| |
| // This is used by BPELDetailsEditor to implement createDetailsInputCommand() which is used |
| // to support Undo/Redo functionality in the details area |
| protected EditPart lastSelectedEditPart; |
| |
| // The selection provider that maps EditParts to their corresponding model objects |
| private BPELAdaptingSelectionProvider adaptingSelectionProvider; |
| private WeakMultiViewerSelectionProvider weakMultiViewerSelectionProvider; |
| // This is necessary for some EditPart-based actions to work correctly. |
| // private ISelectionProvider filteredEditPartSelectionProvider; |
| |
| // Lists of actions available for context menus, etc. |
| protected Set<IAction> appendNewActions; |
| protected Set<IAction> insertNewActions; |
| protected Set<IAction> changeTypeActions; |
| |
| protected String contributorID; |
| |
| protected ICommandFramework commandFramework; |
| |
| public BPELEditor(DefaultEditDomain ed, BPELMultipageEditorPart multipageEditor) { |
| super(); |
| setEditDomain(ed); |
| this.multipageEditor = multipageEditor; |
| |
| // transferBuffer = new TransferBuffer(); |
| |
| modelAutoUndoRecorder = new ModelAutoUndoRecorder(); |
| } |
| |
| protected class BPELEditorAdapter implements Adapter { |
| public Notifier getTarget() { return null; } |
| public void setTarget(Notifier newTarget) { } |
| public boolean isAdapterForType(Object type) { return (type == BPELEditorAdapter.class); } |
| public void notifyChanged(Notification notification) { } |
| public BPELEditor getBPELEditor() { return BPELEditor.this; } |
| } |
| |
| /** |
| * Given a ResourceSet, this helper identifies the BPELEditor (if any) that created it |
| */ |
| public static BPELEditor getBPELEditor(ResourceSet resourceSet) { |
| Iterator<Adapter> it = resourceSet.eAdapters().iterator(); |
| while (it.hasNext()) { |
| Object next = it.next(); |
| if (next instanceof BPELEditorAdapter) { |
| return ((BPELEditorAdapter)next).getBPELEditor(); |
| } |
| } |
| return null; |
| } |
| |
| public BPELEditModelClient getEditModelClient() { |
| return editModelClient; |
| } |
| |
| public void setEditModelClient(BPELEditModelClient cl) { |
| this.editModelClient = cl; |
| } |
| |
| public ResourceSet getResourceSet() { |
| return getEditModelClient().getEditModel().getResourceSet(); |
| } |
| |
| public Resource getResource() { return getProcess().eResource(); } |
| public ModelAutoUndoRecorder getModelAutoUndoRecorder() { return modelAutoUndoRecorder; } |
| |
| public TransferBuffer getTransferBuffer() { return transferBuffer; } |
| |
| public Set<IAction> getAppendNewActions() { return appendNewActions; } |
| public Set<IAction> getInsertNewActions() { return insertNewActions; } |
| public Set<IAction> getChangeTypeActions() { return changeTypeActions; } |
| |
| /** |
| * @see org.eclipse.gef.ui.parts.GraphicalEditor#configureGraphicalViewer() |
| */ |
| @Override |
| protected void configureGraphicalViewer() { |
| super.configureGraphicalViewer(); |
| |
| GraphicalViewer viewer = getGraphicalViewer(); |
| registerViewer(viewer); |
| GraphicalBPELRootEditPart root = (GraphicalBPELRootEditPart)viewer.getRootEditPart(); |
| ZoomInAction zoomInAction = new ZoomInAction(root.getZoomManager()); |
| zoomInAction.setImageDescriptor(CommonUIPlugin.getDefault().getImageRegistry().getDescriptor(ICommonUIConstants.ICON_ZOOM_IN_TOOL)); |
| getActionRegistry().registerAction(zoomInAction); |
| ZoomOutAction zoomOutAction = new ZoomOutAction(root.getZoomManager()); |
| zoomOutAction.setImageDescriptor(CommonUIPlugin.getDefault().getImageRegistry().getDescriptor(ICommonUIConstants.ICON_ZOOM_OUT_TOOL)); |
| getActionRegistry().registerAction(zoomOutAction); |
| |
| getSite().getKeyBindingService().registerAction(zoomInAction); |
| getSite().getKeyBindingService().registerAction(zoomOutAction); |
| |
| ContextMenuProvider provider = new ProcessContextMenuProvider(this, getActionRegistry()); |
| getGraphicalViewer().setContextMenu(provider); |
| getSite().setSelectionProvider(getAdaptingSelectionProvider()); |
| getSite().registerContextMenu("org.eclipse.bpel.editor.contextmenu", //$NON-NLS-1$ |
| provider, getSite().getSelectionProvider()); |
| getGraphicalViewer().setKeyHandler(new BPELGraphicalKeyHandler(getGraphicalViewer()).setParent(getEditorKeyHandler())); |
| |
| // // Setup the drop target and add our listener to it. |
| // // This will allow us to accept drops from the navigator. |
| // |
| // this.dropTarget = new DropTarget(getGraphicalViewer().getControl(), DND.DROP_NONE | DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK); |
| // // Set transfers to the types that are specified by the helper |
| // // JM |
| // dropTarget.setTransfer(BPELDropTargetListener.getTransferTypes()); |
| // // Create our drop listener and add it to the DropTarget |
| // // JM |
| // this.dropTargetListener = new BPELDropTargetListener(getGraphicalViewer(), this); |
| // dropTarget.addDropListener(dropTargetListener); |
| } |
| |
| // private void createBPELPaletteEntries(PaletteContainer palette) { |
| // BPELPackage bpelPackage = BPELPackage.eINSTANCE; |
| // UIObjectFactoryProvider provider = UIObjectFactoryProvider.getInstance(); |
| // |
| // PaletteCategory basicActionsCategory = new PaletteCategory("Actions"); //$NON-NLS-1$ |
| // String term = BPELTerms.getString("Empty"); //$NON-NLS-1$ |
| // basicActionsCategory.add(new BPELCreationToolEntry(term, term, |
| // provider.getFactoryFor(bpelPackage.getEmpty()))); |
| // basicActionsCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Invoke_35, |
| // Messages.BPELEditor_Invoke_36, |
| // provider.getFactoryFor(bpelPackage.getInvoke()))); |
| // basicActionsCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Receive_4, |
| // Messages.BPELEditor_Receive_5, |
| // provider.getFactoryFor(bpelPackage.getReceive()))); |
| // basicActionsCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Reply_6, |
| // Messages.BPELEditor_Reply_7, |
| // provider.getFactoryFor(bpelPackage.getReply()))); |
| // basicActionsCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Assign_10, |
| // Messages.BPELEditor_Assign_11, |
| // provider.getFactoryFor(bpelPackage.getAssign()))); |
| // basicActionsCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Validate_XML_12, |
| // Messages.BPELEditor_Validate_XML_13, |
| // provider.getFactoryFor(bpelPackage.getValidate()))); |
| // palette.add(basicActionsCategory); |
| // |
| // controlCategory = new PaletteCategory("Control"); //$NON-NLS-1$ |
| // switchEntry = new BPELCreationToolEntry( |
| // Messages.BPELEditor_If_17, |
| // Messages.BPELEditor_If_18, |
| // provider.getFactoryFor(bpelPackage.getIf())); |
| // controlCategory.add(switchEntry); |
| // controlCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Pick_8, |
| // Messages.BPELEditor_Pick_9, |
| // provider.getFactoryFor(bpelPackage.getPick()))); |
| // controlCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_While_19, |
| // Messages.BPELEditor_While_20, |
| // provider.getFactoryFor(bpelPackage.getWhile()))); |
| // controlCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_ForEach_19, |
| // Messages.BPELEditor_ForEach_20, |
| // provider.getFactoryFor(bpelPackage.getForEach()))); |
| // controlCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Repeat_Until_42, |
| // Messages.BPELEditor_Repeat_Until_43, |
| // provider.getFactoryFor(bpelPackage.getRepeatUntil()))); |
| // controlCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Wait_21, |
| // Messages.BPELEditor_Wait_22, |
| // provider.getFactoryFor(bpelPackage.getWait()))); |
| // sequenceEntry = new BPELCreationToolEntry( |
| // Messages.BPELEditor_Sequence_23, |
| // Messages.BPELEditor_Sequence_24, |
| // provider.getFactoryFor(bpelPackage.getSequence())); |
| // controlCategory.add(sequenceEntry); |
| // controlCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Scope_1, |
| // Messages.BPELEditor_Scope_2, |
| // provider.getFactoryFor(bpelPackage.getScope()))); |
| // flowEntry = new BPELCreationToolEntry( |
| // Messages.BPELEditor_Flow_1, |
| // Messages.BPELEditor_Flow_2, |
| // provider.getFactoryFor(bpelPackage.getFlow())); |
| // controlCategory.add(flowEntry); |
| // palette.add(controlCategory); |
| // |
| // PaletteCategory faultCategory = new PaletteCategory("Faults"); //$NON-NLS-1$ |
| // faultCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Exit_26, |
| // Messages.BPELEditor_Exit_27, |
| // provider.getFactoryFor(bpelPackage.getExit()))); |
| // faultCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Throw_28, |
| // Messages.BPELEditor_Throw_29, |
| // provider.getFactoryFor(bpelPackage.getThrow()))); |
| // faultCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_ReThrow_1, |
| // Messages.BPELEditor_ReThrow_2, |
| // provider.getFactoryFor(bpelPackage.getRethrow()))); |
| // faultCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_Compensate_1, |
| // Messages.BPELEditor_Compensate_2, |
| // provider.getFactoryFor(bpelPackage.getCompensate()))); |
| // faultCategory.add(new BPELCreationToolEntry( |
| // Messages.BPELEditor_CompensateScope_1, |
| // Messages.BPELEditor_CompensateScope_2, |
| // provider.getFactoryFor(bpelPackage.getCompensateScope()))); |
| // |
| // palette.add(faultCategory); |
| // |
| // } |
| |
| // private void createTopControlPaletteEntries(PaletteRoot root) { |
| // PaletteGroup controlGroup = new PaletteGroup(Messages.BPELEditor_Top_Control_Group_37); |
| // |
| // SelectionToolEntry selectionTool = new SelectionToolEntry(Messages.BPELEditor_Selection_Tool_38); |
| // controlGroup.add(selectionTool); |
| // |
| // MarqueeToolEntry marqueeTool = new MarqueeToolEntry(Messages.BPELEditor_Marquee_Tool); |
| // controlGroup.add(marqueeTool); |
| // |
| // root.add(controlGroup); |
| // root.setDefaultEntry(selectionTool); |
| // } |
| |
| /** |
| * @see org.eclipse.ui.IWorkbenchPart#dispose() |
| */ |
| @Override |
| public void dispose() { |
| |
| if (editModelClient != null) { |
| editModelClient.getEditModel().getResourceSet().eAdapters().remove(getEditorAdapter()); |
| editModelClient.dispose(); |
| editModelClient = null; |
| } |
| |
| if (getGraphicalViewer() != null) { |
| if (selectionChangeListener != null) { |
| getGraphicalViewer().removeSelectionChangedListener(selectionChangeListener); |
| } |
| |
| getGraphicalViewer().setContents(null); |
| |
| if (getGraphicalViewer().getControl() != null && !getGraphicalViewer().getControl().isDisposed()) { |
| getGraphicalViewer().getControl().dispose(); |
| getGraphicalViewer().setControl(null); |
| } |
| } |
| if (getTrayViewer() != null) { |
| getTrayViewer().setContents(null); |
| } |
| if (getEditDomain() != null) { |
| getEditDomain().setPaletteViewer(null); |
| } |
| |
| // if (getPaletteViewer() != null) { |
| // getPaletteViewer().setContents(null); |
| // } |
| if (transferBuffer != null) { |
| transferBuffer.dispose(); |
| } |
| |
| lastSelectedEditPart = null; |
| |
| super.dispose(); |
| |
| // if (dropTarget != null) { |
| // dropTarget.dispose(); |
| // dropTarget = null; |
| // } |
| |
| // ResourceSet resourceSet = getResourceSet(); |
| |
| if (adaptingSelectionProvider != null) { |
| getSite().setSelectionProvider(null); |
| adaptingSelectionProvider = null; |
| } |
| |
| // TODO unhook BPELEditorAdapter from the resource set to avoid unnecessary cyclic garbage. |
| //BPELEditorAdapter bpelEditorAdapter = (BPELEditorAdapter)BPELUtil.adapt( |
| // resourceSet, BPELEditorAdapter.class); |
| //if (bpelEditorAdapter != null) resourceSet.eAdapters().remove(bpelEditorAdapter); |
| |
| if (getEditDomain() != null) { |
| ((BPELEditDomain)getEditDomain()).setProcess(null); |
| } |
| // processResource = null; |
| // if (resourceSet != null) resourceSet.getResources().clear(); |
| // resourceSet = null; |
| // extensionsResource = null; |
| // if (extensionMap != null) extensionMap.clear(); |
| // extensionMap = null; |
| modelAutoUndoRecorder = null; |
| |
| if (getSelectionActions() != null) { |
| getSelectionActions().clear(); |
| } |
| if (getPropertyActions() != null) { |
| getPropertyActions().clear(); |
| } |
| if (getActionRegistry() != null) { |
| getActionRegistry().dispose(); |
| setActionRegistry(null); |
| } |
| |
| // JM: Replace this with lifecycle extensions |
| //cleanupGeneratedFiles(); |
| } |
| |
| // JM: Replace this with lifecycle extensions |
| // /** |
| // * If we don't have references to the generated files anymore we should delete them. |
| // */ |
| // protected void cleanupGeneratedFiles() { |
| // IFile bpelFile = getFileInput(); |
| // if (!bpelFile.exists()) return; // if the bpel file is gone there's nothing to be done |
| // |
| // // force and wait the index handler to run so we don't delete the wrong files |
| // IIndexManager.INSTANCE.addFileToIndex(bpelFile, null); |
| // List candidates = new ArrayList(Arrays.asList(StampHelper.findGeneratedFiles(bpelFile))); |
| // IndexSearcher indexSearcher = new IndexSearcher(); |
| // try { |
| // FileRefInfo[] matches = indexSearcher.findFileReferences(bpelFile, IIndexSearch.ANY_FILE, null, new NullProgressMonitor()); |
| // if (matches.length > 0) { |
| // FileInfo[] infos = matches[0].getReferencedFiles(); |
| // for (int i = 0; i < infos.length; i++) { |
| // FileInfo info = infos[i]; |
| // candidates.remove(info.getFile()); |
| // } |
| // } |
| // } catch (InterruptedException e) { |
| // BPELUIPlugin.log(e); |
| // } |
| // |
| // if (!candidates.isEmpty()) { |
| // try { |
| // ResourcesPlugin.getWorkspace().delete((IFile[]) candidates.toArray(new IFile[candidates.size()]), true, null); |
| // } catch (CoreException e) { |
| // BPELUIPlugin.log(e); |
| // } |
| // } |
| // } |
| |
| |
| /** |
| * @see org.eclipse.ui.IEditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public void doSave(IProgressMonitor progressMonitor) { |
| getCommandFramework().applyCurrentChange(); |
| |
| removeUnusedExtensions(); |
| // Add all imports and namespaces to the artifacts file before saving. |
| if (getEditModelClient().getArtifactsResourceInfo() != null) { |
| Resource artifactsResource = getEditModelClient().getArtifactsResourceInfo().getResource(); |
| |
| if (artifactsResource instanceof WSDLResourceImpl) { |
| // Add any missing imports/namespaces before saving! |
| if (!artifactsResource.getContents().isEmpty()) { |
| Definition def = (Definition)artifactsResource.getContents().get(0); |
| // --- WDG: temp hack! |
| String TNS = def.getTargetNamespace(); |
| if (TNS == null) { |
| TNS = def.getNamespace("tns"); //$NON-NLS-1$ |
| if (TNS == null) TNS = "UGGH"; |
| def.setTargetNamespace(TNS); |
| } else { |
| def.addNamespace("tns", TNS); //$NON-NLS-1$ |
| } |
| // --- |
| |
| def.getEImports().clear(); |
| |
| WSDLImportHelper.addAllImportsAndNamespaces(def, |
| getEditModelClient().getPrimaryResourceInfo().getFile()); |
| |
| // This doesn't seem to introduce an updateElement automatically, |
| // so do it manually now, so that RolePortTypes (for example) who |
| // are affected by the new namespace will know about it. |
| ((DefinitionImpl)def).updateElement(); |
| } |
| } |
| } |
| try { |
| getExtensionsResource().setModified(false); |
| getEditModelClient().saveAll(progressMonitor); |
| |
| //getModelDirtyTracker().markSaveLocation(); |
| |
| } finally { |
| updateTitle(); |
| } |
| // Put the timestamp of the bpel file into the bpelex file. |
| // Bugzilla 324165 |
| // if the Resource failed to parse then the Process is null. |
| // use the model client to get the IFile resource instead of getting it from Process |
| IFile bpelFile = getEditModelClient().getPrimaryResourceInfo().getFile(); |
| long modificationStamp = bpelFile.getLocalTimeStamp(); |
| ProcessExtension processExtension = (ProcessExtension)ModelHelper.getExtension(getProcess()); |
| if (processExtension!=null) |
| { |
| processExtension.setModificationStamp(modificationStamp); |
| getExtensionsResource().setModified(true); |
| } |
| getEditModelClient().saveAll(progressMonitor); |
| } |
| |
| // Disable our Save As functionality. |
| @Override |
| public boolean isSaveAsAllowed() { |
| return false; |
| } |
| |
| /** |
| * @see org.eclipse.ui.IEditorPart#doSaveAs() |
| */ |
| @Override |
| public void doSaveAs() { |
| getCommandFramework().applyCurrentChange(); |
| performSaveAs(); |
| updateTitle(); |
| } |
| |
| protected boolean performSaveAs() { |
| SaveAsDialog saveAsDialog = new SaveAsDialog(getSite().getShell()); |
| saveAsDialog.setOriginalFile(getFileInput()); |
| saveAsDialog.open(); |
| |
| IPath path = saveAsDialog.getResult(); |
| if (path != null) { |
| return getEditModelClient().savePrimaryResourceAs( |
| ResourcesPlugin.getWorkspace().getRoot().getFile(path), |
| getEditorSite().getActionBars().getStatusLineManager().getProgressMonitor()); |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Overridden to install our own help context for the palette. |
| */ |
| @Override |
| protected PaletteViewerProvider createPaletteViewerProvider() { |
| return new PaletteViewerProvider(getEditDomain()) { |
| @Override |
| protected void configurePaletteViewer(PaletteViewer viewer) { |
| super.configurePaletteViewer(viewer); |
| // viewer.setCustomizer(new LogicPaletteCustomizer()); |
| viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer)); |
| |
| // As the palette has no own help context, install our help context |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(viewer.getControl(), IHelpContextIds.EDITOR_PALETTE); |
| } |
| }; |
| } |
| |
| // protected PaletteRoot createPaletteRoot() { |
| // PaletteRoot paletteRoot = new PaletteRoot(); |
| // createTopControlPaletteEntries(paletteRoot); |
| // createBPELPaletteEntries(paletteRoot); |
| // createBottomControlPaletteEntries(paletteRoot); |
| // return paletteRoot; |
| // } |
| |
| /** |
| * @see org.eclipse.ui.IEditorPart#isDirty() |
| */ |
| /*public boolean isDirty() { |
| return getCommandStack().isDirty(); |
| }*/ |
| |
| /** |
| * @see org.eclipse.gef.ui.parts.GraphicalEditor#initializeGraphicalViewer() |
| */ |
| @Override |
| protected void initializeGraphicalViewer() { |
| ///FIXME moved to multi |
| //initializeFileChangeListener(); |
| //initializeRefactoringListeners(); |
| |
| getGraphicalViewer().setEditPartFactory(new BPELEditPartFactory()); |
| |
| BPELUIPlugin.INSTANCE.getPreferenceStore().setValue(IBPELUIConstants.PREF_SHOW_FREEFORM_FLOW, true); |
| GraphicalViewer viewer = getGraphicalViewer(); |
| viewer.setContents(getProcess()); |
| |
| viewer.addDropTargetListener( new FileDropTargetListener(viewer,this) ); |
| viewer.addDropTargetListener( new TextDropTargetListener(viewer,this) ); |
| viewer.addDropTargetListener( new BPELTextTransferDropTargetListener(viewer, this)); |
| viewer.addDropTargetListener( new BPELTemplateTransferDropTargetListener(viewer)); |
| |
| |
| |
| this.selectionChangeListener = new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| StructuredSelection selection = (StructuredSelection)event.getSelection(); |
| if (selection.isEmpty()) { |
| return; |
| } |
| // if this is a multi-selection we should not present anything on the details area |
| if (selection.size() > 1) { |
| // TODO: This doesn't work |
| // getBPELDetailsEditor().getDetailsArea().setInput(null); |
| } else { |
| final Object o = selection.getFirstElement(); |
| if (o instanceof EditPart) { |
| // CAREFUL: must setInput() on the DetailsArea *before* we remember |
| // the lastSelectedEditPart (because setInput() might execute a pending |
| // command for an IOngoingChange whose wrapper will not execute correctly |
| // unless lastSelectedEditPart has its old value). |
| lastSelectedEditPart = (EditPart)o; |
| } |
| } |
| } |
| }; |
| this.traySelectionChangeListener = new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| StructuredSelection selection = (StructuredSelection)event.getSelection(); |
| if (selection.isEmpty()) { |
| return; |
| } |
| // if this is a multi-selection we should not present anything on the details area |
| if (selection.size() > 1) { |
| // TODO: This doesn't work. |
| // getBPELDetailsEditor().getDetailsArea().setInput(null); |
| } else { |
| final Object o = selection.getFirstElement(); |
| if (o instanceof EditPart) { |
| // CAREFUL: must setInput() on the DetailsArea *before* we remember |
| // the lastSelectedEditPart (because setInput() might execute a pending |
| // command for an IOngoingChange whose wrapper will not execute correctly |
| // unless lastSelectedEditPart has its old value). |
| lastSelectedEditPart = (EditPart)o; |
| } |
| } |
| } |
| }; |
| getGraphicalViewer().addSelectionChangedListener(this.selectionChangeListener); |
| arrangeEditParts(getGraphicalViewer()); |
| } |
| public void arrangeEditParts(GraphicalViewer graphicalViewer) { |
| // Make a list of all FlowEditParts whose children all have no positional metadata |
| List<FlowEditPart> flowsToArrange = new ArrayList<FlowEditPart>(); |
| List<Point> flowChildlocations = new ArrayList<Point>(); |
| |
| for (TreeIterator<EObject> it = getProcess().eAllContents(); it.hasNext(); ) { |
| EObject model = it.next(); |
| if (model instanceof Flow) { |
| boolean missingLoc = false; |
| for (Iterator<Activity> it2 = ((Flow)model).getActivities().iterator(); |
| !missingLoc && it2.hasNext(); ) |
| { |
| Activity child = it2.next(); |
| if (child == null) continue; |
| Point loc = ModelHelper.getLocation(child); |
| if (loc.x == Integer.MIN_VALUE) missingLoc = true; |
| flowChildlocations.add(new Point(loc)); |
| } |
| // Bugzilla 319215 |
| // The problem with the above check for a "missing location" of Flow |
| // children is that the default x & y values are zero if the extension |
| // model is missing. This would be the case if the BPEL process was |
| // imported as text from somewhere. In this case, all x/y coordinates |
| // of all Flow children will be 0, so it suffices to check if two children |
| // have the same x & y coordinates. |
| if (flowChildlocations.size()>1) |
| { |
| for ( int i=0; !missingLoc && i<flowChildlocations.size(); ++i ) |
| { |
| int x = flowChildlocations.get(i).x; |
| int y = flowChildlocations.get(i).y; |
| for ( int j=i+1; !missingLoc && j<flowChildlocations.size(); ++j ) |
| { |
| Point loc = flowChildlocations.get(j); |
| if (loc.x == x && loc.y==y) |
| missingLoc = true; |
| } |
| } |
| } |
| if (missingLoc) { |
| EditPart editPart = (EditPart)graphicalViewer.getEditPartRegistry().get(model); |
| if (editPart instanceof FlowEditPart) flowsToArrange.add((FlowEditPart) editPart); |
| } |
| } |
| } |
| |
| BPELUtil.sortFlowList(flowsToArrange); |
| for (FlowEditPart flowEditPart : flowsToArrange) { |
| flowEditPart.doImmediateAutoLayout(); |
| } |
| } |
| |
| |
| @Override |
| public void commandStackChanged(EventObject event) { |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| super.commandStackChanged(event); |
| } |
| |
| /** |
| * Returns the KeyHandler with common bindings for both the Outline and Graphical Views. |
| */ |
| protected KeyHandler getKeyHandler(){ |
| if (keyHandler == null) { |
| keyHandler = new KeyHandler(); |
| keyHandler.put(KeyStroke.getPressed(SWT.DEL, 127, 0), getActionRegistry().getAction(ActionFactory.DELETE.getId())); |
| } |
| return keyHandler; |
| } |
| |
| /** |
| * Returns the KeyHandler with common bindings for both the Outline and Graphical Views. |
| */ |
| protected KeyHandler getEditorKeyHandler(){ |
| if (keyHandler == null) { |
| keyHandler = new KeyHandler(); |
| keyHandler.put(KeyStroke.getPressed(SWT.DEL, 127, 0), getActionRegistry().getAction(ActionFactory.DELETE.getId())); |
| keyHandler.put(KeyStroke.getPressed(SWT.PAGE_UP, 0), new Action() { |
| @Override |
| public void run() { |
| ((ScrollingBPELGraphicalViewer)getGraphicalViewer()).scrollVertical(true); |
| } |
| }); |
| keyHandler.put(KeyStroke.getPressed(SWT.PAGE_DOWN, 0), new Action() { |
| @Override |
| public void run() { |
| ((ScrollingBPELGraphicalViewer)getGraphicalViewer()).scrollVertical(false); |
| } |
| }); |
| keyHandler.put(KeyStroke.getPressed(SWT.HOME, 0), new Action() { |
| @Override |
| public void run() { |
| ((ScrollingBPELGraphicalViewer)getGraphicalViewer()).scrollHorizontal(true); |
| } |
| }); |
| keyHandler.put(KeyStroke.getPressed(SWT.END, 0), new Action() { |
| @Override |
| public void run() { |
| ((ScrollingBPELGraphicalViewer)getGraphicalViewer()).scrollHorizontal(false); |
| } |
| }); |
| } |
| return keyHandler; |
| } |
| |
| // /** |
| // * @see org.eclipse.core.runtime.IAdaptable#getAdapter(Class) |
| // */ |
| // public Object getAdapter(Class type) { |
| //// if (type == ZoomManager.class) |
| //// return ((ScalableFreeformRootEditPart) getGraphicalViewer().getRootEditPart()) |
| //// .getZoomManager(); |
| // return super.getAdapter(type); |
| // } |
| |
| protected void replaceSelectionAction(ActionRegistry registry, IAction action) { |
| IAction oldAction = registry.getAction(action.getId()); |
| if (oldAction != null) { |
| registry.removeAction(oldAction); |
| getSelectionActions().remove(oldAction.getId()); |
| } |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| } |
| |
| /** |
| * @see org.eclipse.gef.ui.parts.GraphicalEditor#createActions() |
| */ |
| @Override |
| protected void createActions() { |
| // super.createActions(); |
| ActionRegistry registry = getActionRegistry(); |
| IAction action; |
| |
| // Oleg: These actions were copy-pasted from GraphicalEditor |
| // Probably we need to remove some of them |
| action = new UndoAction(this); |
| registry.registerAction(action); |
| getStackActions().add(action.getId()); |
| |
| action = new RedoAction(this); |
| registry.registerAction(action); |
| getStackActions().add(action.getId()); |
| |
| action = new SelectAllAction(this); |
| registry.registerAction(action); |
| |
| action = new SaveAction(this); |
| registry.registerAction(action); |
| getPropertyActions().add(action.getId()); |
| |
| registry.registerAction(new PrintAction(this)); |
| |
| // hook up some custom actions that are specialized versions of |
| // the default actions. |
| action = new BPELDeleteAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELCutAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELCopyAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELPasteAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELDuplicateAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new RevertAction(this); |
| registry.registerAction(action); |
| getPropertyActions().add(action.getId()); |
| |
| action = new RenameAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new ToggleAutoFlowLayout(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new ToggleShowFaultHandler(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new ToggleShowCompensationHandler(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new ToggleShowTerminationHandler(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new ToggleShowEventHandler(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new AutoArrangeFlowsAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new ToggleLayoutOrientationAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| // show properties action |
| ShowViewAction showViewAction = new ShowPropertiesViewAction(); |
| showViewAction.setPage( getSite().getPage() ); |
| registry.registerAction(showViewAction); |
| |
| // Show Palette in Palette View action |
| showViewAction = new ShowPaletteInPaletteViewAction(); |
| showViewAction.setPage( getSite().getPage() ); |
| registry.registerAction(showViewAction); |
| |
| |
| action = new BPELPrintAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELAddChildInTrayAction(this, |
| PartnerLinksEditPart.class, |
| Messages.BPELEditor_addPartnerLink, |
| BPELUIPlugin.INSTANCE.getImageDescriptor(IBPELUIConstants.ICON_PARTNER_IN_16)); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| // action = new BPELAddChildInTrayAction(this, |
| // PartnerLinksEditPart.class, |
| // Messages.BPELEditor_addInterfacePartner, |
| // BPELUIPlugin.getPlugin().getImageDescriptor(IBPELUIConstants.ICON_PARTNER_IN_16)); |
| // registry.registerAction(action); |
| // getSelectionActions().add(action.getId()); |
| // |
| // action = new BPELAddChildInTrayAction(this, |
| // ReferencePartnerLinksEditPart.class, |
| // Messages.BPELEditor_addReferencePartner, |
| // BPELUIPlugin.getPlugin().getImageDescriptor(IBPELUIConstants.ICON_PARTNER_OUT_16)); |
| // registry.registerAction(action); |
| // getSelectionActions().add(action.getId()); |
| |
| action = new BPELAddChildInTrayAction(this, |
| VariablesEditPart.class, |
| Messages.BPELEditor_addVariable, |
| BPELUIPlugin.INSTANCE.getImageDescriptor(IBPELUIConstants.ICON_VARIABLE_16)); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELAddChildInTrayAction(this, |
| CorrelationSetsEditPart.class, |
| Messages.BPELEditor_addCorrelationSet, |
| BPELUIPlugin.INSTANCE.getImageDescriptor(IBPELUIConstants.ICON_CORRELATIONSET_16)); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new BPELAddChildInTrayAction(this, |
| MessageExchangesEditPart.class, |
| Messages.BPELEditor_addMessageExchange, |
| BPELUIPlugin.INSTANCE.getImageDescriptor(IBPELUIConstants.ICON_EXIT_16));//TODO - replace icon with right one |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| |
| action = new MakePartner2WayAction(this); |
| registry.registerAction(action); |
| getSelectionActions().add(action.getId()); |
| } |
| |
| /** |
| * Create the Add, Insert and Change Type actions to be used in pop-up menus. |
| * They reflect what is available from the palette. |
| */ |
| protected void createPaletteDependentActions() { |
| Comparator<IAction> actionComparator = new Comparator<IAction>() { |
| Collator collator = Collator.getInstance(); |
| public int compare(IAction o1, IAction o2) { |
| return collator.compare(o1.getText(), o2.getText()); |
| } |
| }; |
| |
| appendNewActions = new TreeSet<IAction>(actionComparator); |
| insertNewActions = new TreeSet<IAction>(actionComparator); |
| changeTypeActions = new TreeSet<IAction>(actionComparator); |
| createPaletteDependentActions(getPaletteRoot()); |
| } |
| |
| protected void createPaletteDependentActions(PaletteContainer container) { |
| ActionRegistry registry = getActionRegistry(); |
| for (Iterator iter = container.getChildren().iterator(); iter.hasNext();) { |
| Object element = iter.next(); |
| if (element instanceof PaletteContainer) { |
| createPaletteDependentActions((PaletteContainer)element); |
| } else if (element instanceof BPELCreationToolEntry) { |
| BPELCreationToolEntry entry = (BPELCreationToolEntry) element; |
| AbstractUIObjectFactory factory = entry.getUIObjectFactory(); |
| |
| // append |
| IAction action = new AppendNewAction(this, factory); |
| appendNewActions.add(action); |
| registry.registerAction(action); |
| |
| getSelectionActions().add(action.getId()); |
| |
| // insert |
| action = new InsertNewAction(this, factory); |
| registry.registerAction(action); |
| insertNewActions.add(action); |
| getSelectionActions().add(action.getId()); |
| |
| // change type |
| action = new ChangeTypeAction(this, factory); |
| registry.registerAction(action); |
| changeTypeActions.add(action); |
| getSelectionActions().add(action.getId()); |
| } |
| } |
| } |
| |
| public Process getProcess() { |
| IWorkbenchPartSite editorSite = getSite(); |
| if (editorSite instanceof MultiPageEditorSite) { |
| return (Process)((org.eclipse.ui.part.MultiPageEditorSite)getSite()).getMultiPageEditor().getAdapter(Process.class); |
| } |
| return null; |
| } |
| |
| public Resource getExtensionsResource (){ |
| IWorkbenchPartSite editorSite = getSite(); |
| if (editorSite instanceof MultiPageEditorSite) { |
| return (Resource)((org.eclipse.ui.part.MultiPageEditorSite)getSite()).getMultiPageEditor().getAdapter(Resource.class); |
| } |
| return null; |
| } |
| |
| public ExtensionMap getExtensionMap (){ |
| IWorkbenchPartSite editorSite = getSite(); |
| if (editorSite instanceof MultiPageEditorSite) { |
| return (ExtensionMap)((org.eclipse.ui.part.MultiPageEditorSite)getSite()).getMultiPageEditor().getAdapter(ExtensionMap.class); |
| } |
| return null; |
| } |
| |
| //FIXME should we kill it and move all the model listener adapter related |
| //things to BPELMultipageEditorPart? |
| public ModelListenerAdapter getModelListenerAdapter() { |
| IWorkbenchPartSite editorSite = getSite(); |
| if (editorSite instanceof MultiPageEditorSite) { |
| return (ModelListenerAdapter)((org.eclipse.ui.part.MultiPageEditorSite)getSite()).getMultiPageEditor().getAdapter(ModelListenerAdapter.class); |
| } |
| return null; |
| } |
| |
| /** |
| * Overriding to use BPELMultipageEditorPart command stack |
| */ |
| @Override |
| public CommandStack getCommandStack() { |
| IWorkbenchPartSite editorSite = getSite(); |
| if (editorSite instanceof MultiPageEditorSite) { |
| return (CommandStack)((org.eclipse.ui.part.MultiPageEditorSite)getSite()).getMultiPageEditor().getAdapter(CommandStack.class); |
| } |
| return null; |
| } |
| |
| public void setAutoFlowLayout(boolean autoLayout) { |
| BPELUIPlugin.INSTANCE.getPreferenceStore().setValue(IBPELUIConstants.PREF_AUTO_FLOW_LAYOUT, autoLayout); |
| } |
| |
| public boolean getAutoFlowLayout() { |
| return BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(IBPELUIConstants.PREF_AUTO_FLOW_LAYOUT); |
| } |
| |
| // private void createBottomControlPaletteEntries(PaletteContainer palette) { |
| // PaletteGroup controlGroup = new PaletteGroup(Messages.BPELEditor_Bottom_Control_Group_39); |
| // |
| // ZoominToolEntry zoomIn = new ZoominToolEntry(Messages.BPELEditor_Zoom_In_40); |
| // zoomIn.setSmallIcon(CommonUIPlugin.getDefault().getImageRegistry().getDescriptor(ICommonUIConstants.ICON_ZOOM_IN_TOOL)); |
| // controlGroup.add(zoomIn); |
| // ZoomoutToolEntry zoomOut = new ZoomoutToolEntry(Messages.BPELEditor_Zoom_Out_41); |
| // zoomOut.setSmallIcon(CommonUIPlugin.getDefault().getImageRegistry().getDescriptor(ICommonUIConstants.ICON_ZOOM_OUT_TOOL)); |
| // controlGroup.add(zoomOut); |
| // |
| // palette.add(controlGroup); |
| // } |
| |
| /** |
| * Override createGraphicalViewer. We have to have our own graphical viewer so that |
| * we can put extra layers in the root edit part |
| */ |
| @Override |
| protected void createGraphicalViewer(Composite parent) { |
| GraphicalViewer viewer = new ScrollingBPELGraphicalViewer(); |
| viewer.createControl(parent); |
| setGraphicalViewer(viewer); |
| configureGraphicalViewer(); |
| hookGraphicalViewer(); |
| initializeGraphicalViewer(); |
| |
| PlatformUI.getWorkbench().getHelpSystem().setHelp( |
| parent, IHelpContextIds.EDITOR_CANVAS); |
| } |
| |
| @Override |
| protected void hookGraphicalViewer() { |
| // Do nothing. Don't call super because it will override our |
| // preference for selection provider and synchronizer. |
| } |
| /** |
| * Override to make public. |
| */ |
| @Override |
| public void setGraphicalViewer(GraphicalViewer viewer) { |
| super.setGraphicalViewer(viewer); |
| } |
| |
| public void refreshGraphicalViewer() { |
| BPELUtil.regenerateVisuals(getProcess(), getGraphicalViewer()); |
| } |
| |
| /** |
| * Helper to set canvas selection to a specific model object (e.g. for details area) |
| * @param modelObject |
| */ |
| public void selectModelObject(Object modelObject) { |
| setFocus(); // give focus to the editor so that it can notify the properties view of input change |
| if (modelObject == null) { |
| adaptingSelectionProvider.setSelection(StructuredSelection.EMPTY); |
| } else { |
| adaptingSelectionProvider.setSelection(new StructuredSelection(modelObject)); |
| } |
| } |
| |
| /** |
| * Return the selected model object(s). The debugger will call |
| * this. |
| * @return The selected model objects. |
| */ |
| public ISelection getSelection() { |
| ISelection editPartSelection = getGraphicalViewer().getSelection(); |
| if (editPartSelection == null || !(editPartSelection instanceof StructuredSelection) || editPartSelection.isEmpty()) { |
| return StructuredSelection.EMPTY; |
| } |
| ArrayList<Object> list = new ArrayList<Object>(); |
| Iterator it = ((StructuredSelection)editPartSelection).iterator(); |
| while (it.hasNext()) { |
| Object o = it.next(); |
| if (o instanceof EditPart) { |
| list.add(((EditPart)o).getModel()); |
| } |
| } |
| return new StructuredSelection(list); |
| } |
| |
| public AdaptingSelectionProvider getAdaptingSelectionProvider() { |
| if (adaptingSelectionProvider == null) { |
| adaptingSelectionProvider = new BPELAdaptingSelectionProvider(); |
| } |
| return adaptingSelectionProvider; |
| } |
| |
| private MultiViewerSelectionProvider getMultiViewerSelectionProvider() { |
| if (weakMultiViewerSelectionProvider == null) { |
| weakMultiViewerSelectionProvider = new WeakMultiViewerSelectionProvider() { |
| protected ISelection cachedAdaptingSelection; |
| @Override |
| public ISelection getSelection() { |
| // HACK to fix selection coherency problems: |
| // If the AdaptingSelectionProvider selection has changed, assume ours |
| // has changed as well! |
| if (getAdaptingSelectionProvider().getSelection() != cachedAdaptingSelection) { |
| cachedSelection = null; // force super to recalculate |
| } |
| return super.getSelection(); |
| } |
| }; |
| } |
| return weakMultiViewerSelectionProvider; |
| } |
| |
| // private ISelectionProvider getFilteredEditPartSelectionProvider() { |
| // if (filteredEditPartSelectionProvider == null) { |
| // filteredEditPartSelectionProvider = new ISelectionProvider() { |
| // public void addSelectionChangedListener(ISelectionChangedListener listener) { } |
| // public void removeSelectionChangedListener(ISelectionChangedListener listener) { } |
| // public ISelection getSelection() { |
| // return adaptingSelectionProvider.getEditPartSelection(); |
| // } |
| // public void setSelection(ISelection selection) { } |
| // }; |
| // } |
| // return filteredEditPartSelectionProvider; |
| // } |
| |
| protected BPELEditorAdapter getEditorAdapter() { |
| return editorAdapter; |
| } |
| |
| /** |
| * Override getGraphicalViewer() to make the method public |
| */ |
| @Override |
| public GraphicalViewer getGraphicalViewer() { |
| return super.getGraphicalViewer(); |
| } |
| |
| /** |
| * Cause the edit part for the given model object to refresh its hover help. |
| */ |
| public void refreshHoverHelp(EObject modelObject) { |
| EditPart editPart = (EditPart)getGraphicalViewer().getEditPartRegistry().get(modelObject); |
| if (editPart instanceof IHoverHelperSupport) { |
| ((IHoverHelperSupport)editPart).refreshHoverHelp(); |
| } |
| } |
| |
| /** |
| * Cause all edit parts to refresh their hover help. |
| */ |
| public void refreshHoverHelp() { |
| BPELUtil.visitModelDepthFirst(getProcess(), new IModelVisitor() { |
| public boolean visit(Object modelObject) { |
| EditPart editPart = (EditPart)getGraphicalViewer().getEditPartRegistry().get(modelObject); |
| if (editPart == null) editPart = (EditPart)getTrayViewer().getEditPartRegistry().get(modelObject); |
| if (editPart instanceof IHoverHelperSupport) { |
| ((IHoverHelperSupport)editPart).refreshHoverHelp(); |
| } |
| return true; |
| } |
| }); |
| } |
| |
| @Override |
| public void createPartControl(Composite parent) { |
| super.createPartControl(parent); |
| getTrayComposite().setState(TrayComposite.STATE_EXPANDED); |
| getTrayComposite().setTrayWidth(150); |
| getEditorSite().getKeyBindingService(); |
| selectModelObject(getProcess()); |
| } |
| |
| protected IFile getFileInput() { |
| return (IFile) getEditorInput().getAdapter(IFile.class); |
| } |
| |
| /** |
| * This is called during startup. |
| */ |
| @Override |
| public void init(IEditorSite site, IEditorInput editorInput) throws PartInitException { |
| |
| IFile input = (IFile) editorInput.getAdapter(IFile.class); |
| if (input == null) |
| throw new PartInitException(Messages.BPELEditor_Cant_read_input_file_1); |
| |
| super.init( site, editorInput ); |
| transferBuffer = new TransferBuffer(getSite().getShell().getDisplay()); |
| |
| // remove the listener on the command stack created by the graphical editor |
| getCommandStack().removeCommandStackListener(this); |
| |
| ResourceSet resourceSet = getEditModelClient().getEditModel().getResourceSet(); |
| |
| // TODO: does this stuff have to go? it won't work with shared models.. |
| resourceSet.eAdapters().add(getModelListenerAdapter()); |
| resourceSet.eAdapters().add(editorAdapter = new BPELEditorAdapter()); |
| getModelListenerAdapter().setLinkNotificationAdapter(new LinkNotificationAdapter(this)); |
| getCommandStack().addCommandStackListener(getModelListenerAdapter()); |
| |
| commandFramework = new EditModelCommandFramework(getEditModelClient().getCommandStack()); |
| |
| // add a listener to the shared command stack |
| getCommandStack().addCommandStackListener(this); |
| |
| // Scan the model to see if there are any invalid elements that need to be |
| // removed (there are some elements that if invalid will not appear in |
| // the UI and thus need to be removed automatically). |
| // Do this after the command framework is created and the listener |
| // is added to it. |
| // JM |
| // if (BPELUtil.removeInvalidElements(process)) { |
| // MessageDialog.openInformation(getSite().getShell(), |
| // Messages.getString("validationInfo.dialog.title"), //$NON-NLS-1$ |
| // Messages.getString("validationInfo.invalidElementsRemoved")); //$NON-NLS-1$ |
| // getCommandFramework().execute(new DummyCommand()); |
| // } |
| // |
| |
| // these can only be created after we load the model |
| // since it affects the available items in the palette |
| createPaletteDependentActions(); |
| } |
| |
| // This is for loading the model within the editor |
| // REMINDER: Any changes to this method, consider corresponding changes to |
| // the loadModelWithoutEditModel() method! |
| /*protected void loadModel() { |
| // TODO: This two lines are a workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=72565 |
| EcorePackage instance = EcorePackage.eINSTANCE; |
| instance.eAdapters();*/ |
| |
| /*Resource bpelResource = editModelClient.getPrimaryResourceInfo().getResource(); |
| |
| IFile file = getFileInput(); |
| BPELReader reader = new BPELReader(); |
| reader.read(bpelResource, file, getResourceSet()); |
| |
| this.process = reader.getProcess(); |
| if (getEditDomain() != null) { |
| ((BPELEditDomain)getEditDomain()).setProcess(process); |
| } |
| this.extensionsResource = reader.getExtensionsResource(); |
| this.extensionMap = reader.getExtensionMap(); |
| |
| this.modelListenerAdapter.setExtensionMap(extensionMap);*/ |
| |
| // ProcessExtension processExtension = (ProcessExtension)ModelHelper.getExtension(process); |
| // long stamp = processExtension.getModificationStamp(); |
| // // Be nice if the file is old or doesn't yet have a stamp. |
| // if (stamp != 0) { |
| // long actualStamp = file.getLocalTimeStamp(); |
| // if (stamp != actualStamp) { |
| // // Inform the user that visual information will be discarded, |
| // // and null out the extension map. |
| // // Only inform the user if we actually have a shell; headless clients |
| // // will not be informed. |
| // if (getSite() != null) { |
| // MessageDialog.openWarning(getSite().getShell(), Messages.getString("BPELEditor.Process_Out_Of_Sync_2"), Messages.getString("BPELEditor.Process_has_been_modified_3")); //$NON-NLS-1$ //$NON-NLS-2$ |
| // } |
| // // TODO: Null out and recreate the extension map. Perhaps we need |
| // // to preserve some interesting bits of info about spec compliance |
| // // and implicit sequences. Don't null it out yet until we understand |
| // // all the cases in which this could occur. |
| // //extensionMap = null; |
| // } |
| // } |
| /*}*/ |
| |
| public ICommandFramework getCommandFramework() { return commandFramework; } |
| |
| // Make the method public so the properties sections can access it |
| @Override |
| public ActionRegistry getActionRegistry() { return super.getActionRegistry(); } |
| |
| @Override |
| protected void initializeTrayViewer() { |
| GraphicalViewer viewer = getTrayViewer(); |
| |
| viewer.setEditPartFactory(new BPELTrayEditPartFactory()); |
| viewer.setEditDomain(getEditDomain()); |
| getEditDomain().addViewer(viewer); |
| viewer.addSelectionChangedListener(this.traySelectionChangeListener); |
| registerViewer(viewer); |
| ContextMenuProvider provider = new ProcessContextMenuProvider(this, getActionRegistry()); |
| viewer.setContextMenu(provider); |
| getSite().registerContextMenu("org.eclipse.bpel.editor.tray.contextmenu", //$NON-NLS-1$ |
| provider, getSite().getSelectionProvider()); |
| viewer.setContents(getProcess()); |
| |
| viewer.addDropTargetListener(new FileDropTargetListener(getTrayViewer(), this)); |
| viewer.addDropTargetListener(new TextDropTargetListener(getTrayViewer(), this)); |
| |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(viewer.getControl(), |
| IHelpContextIds.TRAY_DESCRIPTION); |
| } |
| |
| // Register a viewer with the selection providers |
| protected void registerViewer(EditPartViewer viewer) { |
| getAdaptingSelectionProvider().addViewer(viewer); |
| getMultiViewerSelectionProvider().addViewer(viewer); |
| } |
| |
| /** |
| * The editor part name should be the same as the one appearing in the logical view. |
| */ |
| //FIXME should be moved to multi or even removed at all |
| protected void updateTitle() { |
| setPartName(getProcess().getName()); |
| } |
| |
| // protected boolean updateInputFile(IPath filePath) { |
| // if (filePath == null) { |
| // return false; |
| // } |
| // |
| // IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(filePath); |
| // if (file == null) { |
| // return false; |
| // } |
| // |
| // // WDG: changed setInput to setInputWithNotify here. is updateTitle still needed? |
| // setInputWithNotify(new FileEditorInput(file)); |
| // updateTitle(); |
| // return true; |
| // } |
| |
| /** |
| * because our extensions are managed independently of the model and stored in a separate map, we have to make sure |
| * that any extensions that are not used are removed before we serialize |
| * |
| * the easiest way to do that is to make sure that all extensions have eResource attributes set and thus |
| * we know that the extension is mapped to a model object. |
| * |
| * TODO: this is bogus though because it will mess up undo/redo! A better solution |
| * would be to create a second map and save that one, leaving the original unchanged. |
| */ |
| protected void removeUnusedExtensions() { |
| ExtensionMap map = getExtensionMap(); |
| Set<EObject> keyset = map.keySet(); |
| Vector<EObject> deleted = new Vector<EObject>(); |
| for (Iterator<EObject> i = keyset.iterator(); i.hasNext(); ) { |
| EObject model = i.next(); |
| try { |
| if (model.eResource() == null) |
| deleted.add(model); |
| } |
| catch (Exception e) { |
| // object is definitely not valid; |
| deleted.add(model); |
| } |
| } |
| |
| for (int j = 0; j < deleted.size(); j++) |
| map.remove(deleted.get(j)); |
| } |
| |
| /** |
| * @return the artifacts definition model. |
| */ |
| public Definition getArtifactsDefinition() { |
| // TODO: handle the case where resource doesn't exist or is empty |
| Resource artifactsResource = getEditModelClient().getArtifactsResourceInfo().getResource(); |
| return (Definition)artifactsResource.getContents().get(0); |
| } |
| |
| @Override |
| protected String getPaletteAdditionsContributorId() { |
| return IBPELUIConstants.BPEL_EDITOR_ID; |
| } |
| |
| public boolean isHorizontalLayout(){ |
| boolean result = false; |
| IFile file = (IFile)getEditorInput().getAdapter(IFile.class); |
| try { |
| result = Boolean.valueOf(file.getPersistentProperty(IBPELUIConstants.HORIZONTAL_LAYOUT_PROPERTY)); |
| } catch (CoreException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| return result; |
| } |
| |
| public void setHorizontalLayout(boolean horizontal){ |
| IFile file = (IFile)getEditorInput().getAdapter(IFile.class); |
| try { |
| file.setPersistentProperty(IBPELUIConstants.HORIZONTAL_LAYOUT_PROPERTY, Boolean.toString(horizontal)); |
| } catch (CoreException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| |
| public BPELMultipageEditorPart getMultipageEditor() { |
| return multipageEditor; |
| } |
| } |