| package net.sf.taverna.t2.workbench.ui.workflowview; |
| |
| import static java.awt.GraphicsEnvironment.isHeadless; |
| import static java.awt.Toolkit.getDefaultToolkit; |
| import static java.awt.datatransfer.DataFlavor.javaJVMLocalObjectMimeType; |
| import static javax.swing.SwingUtilities.invokeLater; |
| |
| import java.awt.Component; |
| import java.awt.datatransfer.DataFlavor; |
| import java.awt.datatransfer.Transferable; |
| import java.awt.datatransfer.UnsupportedFlavorException; |
| import java.awt.event.ActionEvent; |
| import java.io.IOException; |
| import java.net.URI; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.swing.Action; |
| import javax.swing.JMenuItem; |
| import javax.swing.JPopupMenu; |
| |
| import net.sf.taverna.t2.servicedescriptions.ServiceDescription; |
| import net.sf.taverna.t2.ui.menu.MenuManager; |
| import net.sf.taverna.t2.workbench.design.actions.RemoveProcessorAction; |
| import net.sf.taverna.t2.workbench.design.actions.RenameProcessorAction; |
| import net.sf.taverna.t2.workbench.edits.CompoundEdit; |
| import net.sf.taverna.t2.workbench.edits.Edit; |
| import net.sf.taverna.t2.workbench.edits.EditException; |
| import net.sf.taverna.t2.workbench.edits.EditManager; |
| import net.sf.taverna.t2.workbench.selection.DataflowSelectionModel; |
| import net.sf.taverna.t2.workbench.selection.SelectionManager; |
| import net.sf.taverna.t2.workbench.ui.actions.activity.ActivityConfigurationAction; |
| import net.sf.taverna.t2.workflow.edits.AddChildEdit; |
| import net.sf.taverna.t2.workflow.edits.AddProcessorEdit; |
| |
| import org.apache.log4j.Logger; |
| //import org.jdom.Element; |
| |
| |
| |
| import uk.org.taverna.commons.services.ActivityTypeNotFoundException; |
| import uk.org.taverna.commons.services.InvalidConfigurationException; |
| import uk.org.taverna.commons.services.ServiceRegistry; |
| import uk.org.taverna.scufl2.api.activity.Activity; |
| import uk.org.taverna.scufl2.api.common.Scufl2Tools; |
| import uk.org.taverna.scufl2.api.configurations.Configuration; |
| import uk.org.taverna.scufl2.api.container.WorkflowBundle; |
| import uk.org.taverna.scufl2.api.core.Processor; |
| import uk.org.taverna.scufl2.api.core.Workflow; |
| import uk.org.taverna.scufl2.api.iterationstrategy.CrossProduct; |
| import uk.org.taverna.scufl2.api.port.InputActivityPort; |
| import uk.org.taverna.scufl2.api.port.InputProcessorPort; |
| import uk.org.taverna.scufl2.api.port.OutputActivityPort; |
| import uk.org.taverna.scufl2.api.port.OutputProcessorPort; |
| import uk.org.taverna.scufl2.api.profiles.ProcessorBinding; |
| import uk.org.taverna.scufl2.api.profiles.ProcessorInputPortBinding; |
| import uk.org.taverna.scufl2.api.profiles.ProcessorOutputPortBinding; |
| import uk.org.taverna.scufl2.api.profiles.Profile; |
| |
| /** |
| * Super class for all UIComponentSPIs that display a Workflow |
| * |
| * @author alanrw |
| */ |
| public class WorkflowView { |
| //public static Element copyRepresentation = null; |
| |
| private static Logger logger = Logger.getLogger(WorkflowView.class); |
| |
| private static DataFlavor processorFlavor = null; |
| private static DataFlavor serviceDescriptionDataFlavor = null; |
| //private static HashMap<String, Element> requiredSubworkflows = new HashMap<>(); |
| |
| private static String UNABLE_TO_ADD_SERVICE = "Unable to add service"; |
| @SuppressWarnings("unused") |
| private static String UNABLE_TO_COPY_SERVICE = "Unable to copy service"; |
| |
| @SuppressWarnings("unused") |
| private static Scufl2Tools scufl2Tools = new Scufl2Tools(); |
| |
| static { |
| try { |
| if (serviceDescriptionDataFlavor == null) { |
| serviceDescriptionDataFlavor = new DataFlavor( |
| javaJVMLocalObjectMimeType + ";class=" |
| + ServiceDescription.class.getCanonicalName(), |
| "ServiceDescription", |
| ServiceDescription.class.getClassLoader()); |
| if (processorFlavor == null) |
| processorFlavor = new DataFlavor(javaJVMLocalObjectMimeType |
| + ";class=" + Processor.class.getCanonicalName(), |
| "Processor", Processor.class.getClassLoader()); |
| } |
| } catch (ClassNotFoundException e) { |
| logger.error(e); |
| } |
| } |
| |
| public final static Processor importServiceDescription( |
| ServiceDescription sd, boolean rename, EditManager editManager, |
| MenuManager menuManager, SelectionManager selectionManager, |
| ServiceRegistry serviceRegistry) { |
| Workflow workflow = selectionManager.getSelectedWorkflow(); |
| Profile profile = selectionManager.getSelectedProfile(); |
| |
| Processor processor = new Processor(); |
| processor.setName(sd.getName()); |
| |
| CrossProduct crossProduct = new CrossProduct(); |
| crossProduct.setParent(processor.getIterationStrategyStack()); |
| |
| URI activityType = sd.getActivityType(); |
| |
| Activity activity = new Activity(); |
| activity.setType(activityType); |
| Configuration configuration = sd.getActivityConfiguration(); |
| configuration.setConfigures(activity); |
| |
| ProcessorBinding processorBinding = new ProcessorBinding(); |
| processorBinding.setBoundProcessor(processor); |
| processorBinding.setBoundActivity(activity); |
| |
| try { |
| for (InputActivityPort activityPort : serviceRegistry |
| .getActivityInputPorts(activityType, |
| configuration.getJson())) { |
| // add port to activity |
| activityPort.setParent(activity); |
| // create processor port |
| InputProcessorPort processorPort = new InputProcessorPort( |
| processor, activityPort.getName()); |
| processorPort.setDepth(activityPort.getDepth()); |
| // add a new port binding |
| new ProcessorInputPortBinding(processorBinding, processorPort, |
| activityPort); |
| } |
| for (OutputActivityPort activityPort : serviceRegistry |
| .getActivityOutputPorts(activityType, |
| configuration.getJson())) { |
| // add port to activity |
| activityPort.setParent(activity); |
| // create processor port |
| OutputProcessorPort processorPort = new OutputProcessorPort( |
| processor, activityPort.getName()); |
| processorPort.setDepth(activityPort.getDepth()); |
| processorPort.setGranularDepth(activityPort.getGranularDepth()); |
| // add a new port binding |
| new ProcessorOutputPortBinding(processorBinding, activityPort, |
| processorPort); |
| } |
| } catch (InvalidConfigurationException | ActivityTypeNotFoundException e) { |
| logger.warn("Unable to get activity ports for configuration", e); |
| } |
| |
| List<Edit<?>> editList = new ArrayList<>(); |
| editList.add(new AddChildEdit<>(profile, activity)); |
| editList.add(new AddChildEdit<>(profile, configuration)); |
| editList.add(new AddChildEdit<>(profile, processorBinding)); |
| editList.add(new AddProcessorEdit(workflow, processor)); |
| Edit<?> insertionEdit = sd.getInsertionEdit(workflow, processor, activity); |
| if (insertionEdit != null) |
| editList.add(insertionEdit); |
| try { |
| editManager.doDataflowEdit(workflow.getParent(), new CompoundEdit( |
| editList)); |
| } catch (EditException e) { |
| showException(UNABLE_TO_ADD_SERVICE, e); |
| logger.warn("Could not add processor : edit error", e); |
| processor = null; |
| } |
| |
| if (processor != null && rename) { |
| RenameProcessorAction rpa = new RenameProcessorAction(workflow, |
| processor, null, editManager, selectionManager); |
| rpa.actionPerformed(new ActionEvent(sd, 0, "")); |
| } |
| |
| if (processor != null && sd.isTemplateService()) { |
| Action action = getConfigureAction(processor, menuManager); |
| if (action != null) |
| action.actionPerformed(new ActionEvent(sd, 0, "")); |
| } |
| return processor; |
| } |
| |
| public static Action getConfigureAction(Processor p, MenuManager menuManager) { |
| Action result = null; |
| JPopupMenu dummyMenu = menuManager.createContextMenu(null, p, null); |
| for (Component c : dummyMenu.getComponents()) { |
| logger.debug(c.getClass().getCanonicalName()); |
| if (c instanceof JMenuItem) { |
| JMenuItem menuItem = (JMenuItem) c; |
| Action action = menuItem.getAction(); |
| if (action != null |
| && action instanceof ActivityConfigurationAction |
| && action.isEnabled()) { |
| if (result != null) { |
| // do not return anything if there are two matches |
| // logger.info("Multiple actions " + |
| // action.getClass().getCanonicalName() + " " + |
| // result.getClass().getCanonicalName()); |
| return null; |
| } |
| result = action; |
| } |
| } |
| } |
| return result; |
| } |
| |
| public static void pasteTransferable(Transferable t, |
| EditManager editManager, MenuManager menuManager, |
| SelectionManager selectionManager, ServiceRegistry serviceRegistry) { |
| if (t.isDataFlavorSupported(processorFlavor)) |
| pasteProcessor(t, editManager); |
| else if (t.isDataFlavorSupported(serviceDescriptionDataFlavor)) |
| try { |
| ServiceDescription data = (ServiceDescription) t |
| .getTransferData(serviceDescriptionDataFlavor); |
| importServiceDescription(data, false, editManager, menuManager, |
| selectionManager, serviceRegistry); |
| } catch (UnsupportedFlavorException | IOException e) { |
| showException(UNABLE_TO_ADD_SERVICE, e); |
| logger.error(e); |
| } |
| } |
| |
| public static void pasteTransferable(EditManager editManager, |
| MenuManager menuManager, SelectionManager selectionManager, |
| ServiceRegistry serviceRegistry) { |
| pasteTransferable( |
| getDefaultToolkit().getSystemClipboard().getContents(null), |
| editManager, menuManager, selectionManager, serviceRegistry); |
| } |
| |
| public static void pasteProcessor(Transferable t, EditManager editManager) { |
| //FIXME |
| // try { |
| // Element e = (Element) t.getTransferData(processorFlavor); |
| // WorkflowBundle currentDataflow = (WorkflowBundle) ModelMap.getInstance().getModel( |
| // ModelMapConstants.CURRENT_DATAFLOW); |
| // Processor p = ProcessorXMLDeserializer.getInstance().deserializeProcessor(e, |
| // requiredSubworkflows); |
| // if (p == null) { |
| // return; |
| // } |
| // String newName = Tools.uniqueProcessorName(p.getName(), currentDataflow); |
| // List<Edit<?>> editList = new ArrayList<Edit<?>>(); |
| // |
| // Edits edits = editManager.getEdits(); |
| // if (!newName.equals(p.getName())) { |
| // Edit renameEdit = edits.getRenameProcessorEdit(p, newName); |
| // editList.add(renameEdit); |
| // } |
| // |
| // Activity activity = null; |
| // if (p.getActivityList().size() > 0) { |
| // activity = p.getActivityList().get(0); |
| // } |
| // |
| // List<InputProcessorPort> processorInputPorts = new ArrayList<InputProcessorPort>(); |
| // processorInputPorts.addAll(p.getInputPorts()); |
| // for (InputProcessorPort port : processorInputPorts) { |
| // Edit removePortEdit = edits.getRemoveProcessorInputPortEdit(p, port); |
| // editList.add(removePortEdit); |
| // if (activity != null) { |
| // Edit removePortMapEdit = edits.getRemoveActivityInputPortMappingEdit(activity, |
| // port); |
| // editList.add(removePortMapEdit); |
| // } |
| // } |
| // List<ProcessorOutputPort> processorOutputPorts = new ArrayList<ProcessorOutputPort>(); |
| // processorOutputPorts.addAll(p.getOutputPorts()); |
| // for (ProcessorOutputPort port : processorOutputPorts) { |
| // Edit removePortEdit = edits.getRemoveProcessorOutputPortEdit(p, port); |
| // editList.add(removePortEdit); |
| // if (activity != null) { |
| // Edit removePortMapEdit = edits.getRemoveActivityOutputPortMappingEdit(activity, |
| // port.getName()); |
| // editList.add(removePortMapEdit); |
| // } |
| // } |
| // Edit edit = edits.getAddProcessorEdit(currentDataflow, p); |
| // editList.add(edit); |
| // editManager.doDataflowEdit(currentDataflow, new CompoundEdit(editList)); |
| // } catch (ActivityConfigurationException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (EditException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (ClassNotFoundException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (InstantiationException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (IllegalAccessException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (DeserializationException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (UnsupportedFlavorException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } catch (IOException e) { |
| // showException(UNABLE_TO_ADD_SERVICE, e); |
| // logger.error(e); |
| // } |
| } |
| |
| public static void copyProcessor(SelectionManager selectionManager) { |
| WorkflowBundle currentDataflow = selectionManager.getSelectedWorkflowBundle(); |
| DataflowSelectionModel dataFlowSelectionModel = selectionManager |
| .getDataflowSelectionModel(currentDataflow); |
| // Get all selected components |
| Set<Object> selectedWFComponents = dataFlowSelectionModel.getSelection(); |
| Processor p = null; |
| for (Object selectedWFComponent : selectedWFComponents) |
| if (selectedWFComponent instanceof Processor) { |
| p = (Processor) selectedWFComponent; |
| break; |
| } |
| if (p != null) |
| copyProcessor(p); |
| } |
| |
| public static void copyProcessor(Processor p) { |
| // try { |
| // final Element e = ProcessorXMLSerializer.getInstance().processorToXML(p); |
| // requiredSubworkflows = new HashMap<String, Element>(); |
| // rememberSubworkflows(p, profile); |
| // Transferable t = new Transferable() { |
| // |
| // public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, |
| // IOException { |
| // return e; |
| // } |
| // |
| // public DataFlavor[] getTransferDataFlavors() { |
| // DataFlavor[] result = new DataFlavor[1]; |
| // result[0] = processorFlavor; |
| // return result; |
| // } |
| // |
| // public boolean isDataFlavorSupported(DataFlavor flavor) { |
| // return flavor.equals(processorFlavor); |
| // } |
| // |
| // }; |
| // Toolkit.getDefaultToolkit().getSystemClipboard().setContents(t, null); |
| // PasteGraphComponentAction.setEnabledStatic(true); |
| // } catch (IOException e1) { |
| // showException(UNABLE_TO_COPY_SERVICE, e1); |
| // logger.error(e1); |
| // } catch (JDOMException e1) { |
| // logger.error(UNABLE_TO_COPY_SERVICE, e1); |
| // } catch (SerializationException e) { |
| // logger.error(UNABLE_TO_COPY_SERVICE, e); |
| // } |
| } |
| |
| // private static void rememberSubworkflows(Processor p, Profile profile) throws SerializationException { |
| // |
| // for (ProcessorBinding processorBinding : scufl2Tools.processorBindingsForProcessor(p, profile)) { |
| // Activity a = processorBinding.getBoundActivity(); |
| // if (a.getConfigurableType().equals(URI.create("http://ns.taverna.org.uk/2010/activity/nested-workflow"))) { |
| // NestedDataflow da = (NestedDataflow) a; |
| // Dataflow df = da.getNestedDataflow(); |
| // if (!requiredSubworkflows.containsKey(df.getIdentifier())) { |
| // requiredSubworkflows.put(df.getIdentifier(), DataflowXMLSerializer |
| // .getInstance().serializeDataflow(df)); |
| // for (Processor sp : df.getProcessors()) { |
| // rememberSubworkflows(sp); |
| // } |
| // } |
| // } |
| // } |
| // } |
| |
| public static void cutProcessor(EditManager editManager, SelectionManager selectionManager) { |
| // WorkflowBundle currentDataflow = (WorkflowBundle) ModelMap.getInstance().getModel( |
| // ModelMapConstants.CURRENT_DATAFLOW); |
| // DataflowSelectionModel dataFlowSelectionModel = selectionManager |
| // .getDataflowSelectionModel(currentDataflow); |
| // // Get all selected components |
| // Set<Object> selectedWFComponents = dataFlowSelectionModel.getSelection(); |
| // Processor p = null; |
| // for (Object selectedWFComponent : selectedWFComponents) { |
| // if (selectedWFComponent instanceof Processor) { |
| // p = (Processor) selectedWFComponent; |
| // break; |
| // } |
| // } |
| // if (p != null) { |
| // cutProcessor(p.getParent(), p, null, editManager, selectionManager); |
| // } |
| } |
| |
| public static void cutProcessor(Workflow dataflow, Processor processor, |
| Component component, EditManager editManager, |
| SelectionManager selectionManager) { |
| copyProcessor(processor); |
| new RemoveProcessorAction(dataflow, processor, component, editManager, |
| selectionManager).actionPerformed(null); |
| } |
| |
| private static void showException(String message, Exception e) { |
| if (!isHeadless()) |
| invokeLater(new ShowExceptionRunnable(message, e)); |
| } |
| } |
