/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.taeconfigurator.editors.ui;
import java.text.MessageFormat;
import java.util.List;
import org.apache.uima.UIMAFramework;
import org.apache.uima.analysis_engine.metadata.CapabilityLanguageFlow;
import org.apache.uima.analysis_engine.metadata.FixedFlow;
import org.apache.uima.analysis_engine.metadata.FlowConstraints;
import org.apache.uima.analysis_engine.metadata.FlowControllerDeclaration;
import org.apache.uima.analysis_engine.metadata.impl.CapabilityLanguageFlow_impl;
import org.apache.uima.analysis_engine.metadata.impl.FixedFlow_impl;
import org.apache.uima.analysis_engine.metadata.impl.FlowControllerDeclaration_impl;
import org.apache.uima.flow.FlowControllerDescription;
import org.apache.uima.resource.metadata.Import;
import org.apache.uima.taeconfigurator.Messages;
import org.apache.uima.taeconfigurator.TAEConfiguratorPlugin;
import org.apache.uima.taeconfigurator.editors.MultiPageEditor;
import org.apache.uima.taeconfigurator.editors.ui.dialogs.FindComponentDialog;
import org.apache.uima.taeconfigurator.editors.ui.dialogs.PickTaeForTypesDialog;
import org.apache.uima.taeconfigurator.files.MultiResourceSelectionDialog;
import org.apache.uima.taeconfigurator.model.FlowNodes;
import org.apache.uima.util.XMLizable;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.ui.forms.IManagedForm;
public class FlowSection extends AbstractSection {
public static final String FIXED_FLOW = "Fixed Flow"; //$NON-NLS-1$
public static final String CAPABILITY_LANGUAGE_FLOW = "Capability Language Flow"; //$NON-NLS-1$
public static final String USER_DEFINED_FLOW = "User-defined Flow";
private CCombo flowControllerChoice;
Table flowList; // need access from inner class
private Button upButton;
private Button downButton;
private Label flowControllerGUI;
private Button specifyFlowControllerImportButton;
private Button findFlowControllerDescriptorButton;
private Label flowControllerLabel;
private Label flowControllerKeyLabel;
private Label flowControllerKeyGUI;
// private Label flowControllerSpecifierLabel;
private Label flowChoiceLabel;
private boolean bDisableToolTipHelp;
/**
* creates a section only for aggregate specifiers to define the flow of their delegates
*
* @param editor
* the referenced multipage editor
*/
public FlowSection(MultiPageEditor aEditor, Composite parent) {
super(aEditor, parent, Messages.getString("FlowSection.ComponentEngineFlowTitle"), //$NON-NLS-1$
Messages.getString("FlowSection.ComponentEngineFlowDescription")); //$NON-NLS-1$
}
/*
* Called by the page constructor after all sections are created, to initialize them.
* (non-Javadoc)
*
* @see org.eclipse.ui.forms.IFormPart#initialize(org.eclipse.ui.forms.IManagedForm)
*/
public void initialize(IManagedForm form) {
super.initialize(form);
Composite sectionClient = new2ColumnComposite(this.getSection());
// sectionClient (2 col)
// label / ccombo
// comp2
// comp2a fcButtonContainer
// label / text
((GridData) sectionClient.getLayoutData()).grabExcessHorizontalSpace = false;
flowChoiceLabel = newLabelWithTip(sectionClient, Messages.getString("FlowSection.FlowKind"), //$NON-NLS-1$
Messages.getString("FlowSection.FlowKindTip")); //$NON-NLS-1$
flowControllerChoice = newCComboWithTip(sectionClient, Messages
.getString("FlowSection.FlowKindTip")); //$NON-NLS-1$
flowControllerChoice.add(FIXED_FLOW);
flowControllerChoice.add(CAPABILITY_LANGUAGE_FLOW);
flowControllerChoice.add(USER_DEFINED_FLOW);
Composite comp2 = new2ColumnComposite(sectionClient);
((GridData) comp2.getLayoutData()).horizontalSpan = 2;
((GridData) comp2.getLayoutData()).grabExcessVerticalSpace = false;
Composite comp2a = new2ColumnComposite(comp2);
Composite fcButtonContainer = newButtonContainer(comp2, VERTICAL_BUTTONS, 0);
flowControllerLabel = newLabelWithTip(comp2a, "Flow Controller:",
"The XML descriptor for the Custom Flow Controller");
flowControllerGUI = newUnUpdatableTextWithTip(comp2a, "",
"The XML descriptor for the Custom Flow Controller");
flowControllerGUI.addListener(SWT.MouseDown, this);
flowControllerGUI.addListener(SWT.MouseHover, this);
flowControllerKeyLabel = newLabelWithTip(comp2a, "Key Name:",
"A unique key name for this Flow Controller");
flowControllerKeyGUI = newUnUpdatableTextWithTip(comp2a, "",
"A unique key name for this Flow Controller");
// flowControllerSpecifierLabel = newLabelWithTip(sectionClient, "Specify:",
// "Click the Browse or Search button to specify a Flow Controller");
// Composite fcButtonContainer = newButtonContainer(sectionClient, HORIZONTAL_BUTTONS, 150);
specifyFlowControllerImportButton = newPushButton(fcButtonContainer, "Browse...",
"Click here to specify a locally defined Flow Controller", ENABLED);
findFlowControllerDescriptorButton = newPushButton(fcButtonContainer, "Search",
"Click here to search for a Flow Controller", ENABLED);
// flow list
Composite flowComposite = new2ColumnComposite(sectionClient);
((GridData) flowComposite.getLayoutData()).horizontalSpan = 2;
enableBorders(flowComposite);
toolkit.paintBordersFor(flowComposite);
flowList = newTable(flowComposite, SWT.FULL_SELECTION, 0);
// Buttons
final Composite buttonContainer = newButtonContainer(flowComposite, VERTICAL_BUTTONS, 70);
upButton = newPushButton(buttonContainer, S_UP,
Messages.getString("FlowSection.upTip"), !ENABLED); //$NON-NLS-1$
downButton = newPushButton(buttonContainer, S_DOWN,
Messages.getString("FlowSection.downTip"), !ENABLED); //$NON-NLS-1$
enableBorders(sectionClient);
toolkit.paintBordersFor(sectionClient);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.forms.IFormPart#refresh()
*/
public void refresh() {
super.refresh();
flowList.removeAll();
if (!isAggregate()) {
getSection().setText(Messages.getString("FlowSection.notUsed")); //$NON-NLS-1$
getSection().setDescription(Messages.getString("FlowSection.onlyForAggregates")); //$NON-NLS-1$
} else {
getSection().setText(Messages.getString("FlowSection.ComponentEngineFlowTitle")); //$NON-NLS-1$
getSection().setDescription(Messages.getString("FlowSection.ComponentEngineFlowDescription")); //$NON-NLS-1$
FlowControllerDeclaration fcd = getFlowControllerDeclaration();
flowList.setEnabled(true);
FlowConstraints flowConstraints = getModelFlow();
FlowNodes nodesModel = new FlowNodes(flowConstraints);
String[] nodes = nodesModel.getFlow();
if (null == nodes)
nodesModel.setFlow(nodes = stringArray0);
// add them to the list
for (int i = 0; i < nodes.length; i++) {
TableItem item = new TableItem(flowList, SWT.NONE);
item.setImage(TAEConfiguratorPlugin.getImage(TAEConfiguratorPlugin.IMAGE_ANNOTATOR) //$NON-NLS-1$
);
item.setText(0, nodes[i]);
}
packTable(flowList);
if (null == fcd) {
// Not a custom, user-defined flow
FixedFlow ff;
if (null == flowConstraints) {
// force fixed flow if nothing is specified
getAnalysisEngineMetaData().setFlowConstraints(
flowConstraints = ff = new FixedFlow_impl());
ff.setFixedFlow(stringArray0);
}
String modelFlowType = flowConstraints.getFlowConstraintsType();
flowControllerChoice.setText(modelFlowType
.equals(CapabilityLanguageFlow.FLOW_CONSTRAINTS_TYPE) ? CAPABILITY_LANGUAGE_FLOW
: FIXED_FLOW);
enableFlowControllerGUI(false);
} else {
// User-specified Flow Controller defined
refreshFcd(fcd);
}
}
enable();
}
private void refreshFcd(FlowControllerDeclaration fcd) {
enableFlowControllerGUI(true);
String keyName;
if (null == fcd.getKey() || "".equals(fcd.getKey())) {
keyName = "Warning: no key name is specified";
flowControllerKeyGUI.setToolTipText(
"Use Source tab below to specify a key name " +
"in the <flowController> element, or the imported <flowController>");
} else
keyName = fcd.getKey();
flowControllerKeyGUI.setText(keyName);
Import fcdImport = fcd.getImport();
String fileName = null;
if (null != fcdImport) {
fileName = fcdImport.getLocation();
if (null == fileName || (0 == fileName.length()))
fileName = fcdImport.getName();
}
flowControllerGUI.setText(null == fileName ?
"Warning: no <import> in <flowController>" : fileName);
flowControllerChoice.setText(USER_DEFINED_FLOW);
// must follow label updates
// because this method also does the redraw
// otherwise, label updates are not redrawn...
flowControllerGUI.getParent().redraw();
}
private void enableFlowControllerGUI(boolean enableState) {
flowControllerLabel.setEnabled(enableState);
flowControllerGUI.setEnabled(enableState);
specifyFlowControllerImportButton.setEnabled(enableState);
findFlowControllerDescriptorButton.setEnabled(enableState);
flowControllerKeyLabel.setEnabled(enableState);
// flowControllerSpecifierLabel.setEnabled(enableState);
flowControllerKeyGUI.setEnabled(enableState);
// if (!enableState) {
// flowControllerKeyGUI.setText("");
// flowControllerGUI.setText("");
// }
}
/**
* @return
*/
private FlowConstraints getModelFlow() {
return getAnalysisEngineMetaData().getFlowConstraints();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
*/
public void handleEvent(Event event) {
if (event.widget == flowControllerChoice) {
String flowTypeGUI = flowControllerChoice.getText();
if (null == flowTypeGUI || flowTypeGUI.equals(S_))
return;
String prevFlowTypeGUI;
FlowControllerDeclaration fcd = getFlowControllerDeclaration();
FlowConstraints modelFlow = getModelFlow();
if (null != fcd)
prevFlowTypeGUI = USER_DEFINED_FLOW;
else {
if (null == modelFlow)
prevFlowTypeGUI = "";
else {
String prevFlowType = modelFlow.getFlowConstraintsType();
if (CapabilityLanguageFlow.FLOW_CONSTRAINTS_TYPE.equals(prevFlowType))
prevFlowTypeGUI = CAPABILITY_LANGUAGE_FLOW;
else
prevFlowTypeGUI = FIXED_FLOW;
}
}
if (prevFlowTypeGUI.equals(flowTypeGUI))
return;
CapabilityLanguageFlow clf = null;
FixedFlow ff = null;
String[] nodes = new FlowNodes(modelFlow).getFlow();
if (flowTypeGUI.equals(CAPABILITY_LANGUAGE_FLOW)) {
setFlowControllerDeclaration(null);
getAnalysisEngineMetaData().setFlowConstraints(clf = new CapabilityLanguageFlow_impl());
clf.setCapabilityLanguageFlow(nodes);
} else if (flowTypeGUI.equals(FIXED_FLOW)) {
setFlowControllerDeclaration(null);
getAnalysisEngineMetaData().setFlowConstraints(ff = new FixedFlow_impl());
ff.setFixedFlow(nodes);
} else if (flowTypeGUI.equals(USER_DEFINED_FLOW)) {
// use case: user set user-defined-flow from some other state.
// user will have to fill in the import (CDE only supports that format)
// flow nodes kept, put under "Fixed Flow" arbitrarily
FlowControllerDeclaration newFcd = new FlowControllerDeclaration_impl();
setFlowControllerDeclaration(newFcd);
refreshFcd(newFcd);
getAnalysisEngineMetaData().setFlowConstraints(ff = new FixedFlow_impl());
ff.setFixedFlow(nodes);
}
enable();
setFileDirty();
}
else if (event.widget == upButton) {
String[] nodes = new FlowNodes(getModelFlow()).getFlow();
// update both model and gui: swap nodes
int selection = flowList.getSelectionIndex();
if (selection == 0)
return; // can't move up 0
String temp = nodes[selection - 1];
nodes[selection - 1] = nodes[selection];
nodes[selection] = temp;
finishFlowAction();
flowList.setSelection(selection - 1);
enable(); // after setting selection
} else if (event.widget == downButton) {
String[] nodes = new FlowNodes(getModelFlow()).getFlow();
// update both model and gui: swap nodes
int selection = flowList.getSelectionIndex();
if (selection == flowList.getItemCount() - 1)
return; // can't move down at end of list
String temp = nodes[selection + 1];
nodes[selection + 1] = nodes[selection];
nodes[selection] = temp;
finishFlowAction();
flowList.setSelection(selection + 1);
enable(); // after setting selection
} else if (event.widget == specifyFlowControllerImportButton) {
handleSpecifyFlowController();
} else if (event.widget == findFlowControllerDescriptorButton) {
handleFindFlowController();
} else if (event.widget == flowControllerGUI && event.type == SWT.MouseDown
&& event.button == 3) {
handleContextMenuRequest(event);
} else if (event.widget == flowControllerGUI && event.type == SWT.MouseHover
&& !bDisableToolTipHelp) {
handleHoverHelp(event);
}
// handle selection
else if (event.widget == flowList) {
if (event.type == SWT.Selection) {
enable();
}
if (event.character == SWT.DEL) {
if (flowList.getSelectionIndex() > -1) {
handleRemove();
}
}
}
}
private void handleHoverHelp(Event event) {
String sDesc = "";
FlowControllerDeclaration fcd = editor.getResolvedFlowControllerDeclaration();
String text = flowControllerGUI.getText();
if (null != fcd && !"".equals(text) && null != fcd.getSpecifier()) {
sDesc = getDescriptionForDescriptor(flowControllerGUI.getText(), fcd.getSpecifier());
}
flowControllerGUI.setToolTipText(sDesc);
}
private void handleContextMenuRequest(Event event) {
Import imp = getFlowControllerDeclaration().getImport();
bDisableToolTipHelp = true;
requestPopUpOverImport(imp, flowControllerGUI, event);
bDisableToolTipHelp = false;
}
private void finishFlowAction() {
setFileDirty();
refresh(); // calls enable
}
public void handleRemove() {
// get node to remove
int removedItemIndex = flowList.getSelectionIndex();
String[] nodes = new FlowNodes(getModelFlow()).getFlow();
int origItemCount = nodes.length;
// remove node from array by copying additional items above down 1
for (int i = removedItemIndex + 1; i < origItemCount; i++) {
nodes[i - 1] = nodes[i];
}
// copy array in a smaller one
String newNodes[] = new String[origItemCount - 1];
if (newNodes.length > 0) {
System.arraycopy(nodes, 0, newNodes, 0, newNodes.length);
}
new FlowNodes(getModelFlow()).setFlow(newNodes);
finishFlowAction(); // does also enable() and refresh()
flowList.setSelection(removedItemIndex - 1);
enable(); // after setting selection
}
/**
* Adds a node to the flowList
*
* @param node
* the key of the delegate
*/
public void addNode(String node) {
FlowConstraints flowConstraints = getModelFlow();
if (null == flowConstraints) {
// no constraints declared
// set up Fix Flow style of constraints
// This can happen if the style is user-defined flow
flowConstraints = UIMAFramework.getResourceSpecifierFactory().createFixedFlow();
getAnalysisEngineMetaData().setFlowConstraints(flowConstraints);
}
FlowNodes flowNodes = new FlowNodes(flowConstraints);
String[] nodes = flowNodes.getFlow();
if (nodes == null) {
nodes = new String[] { node };
flowNodes.setFlow(nodes);
} else {
// create a new String array and copy old Strings
String newNodes[] = new String[nodes.length + 1];
System.arraycopy(nodes, 0, newNodes, 0, nodes.length);
newNodes[newNodes.length - 1] = node;
flowNodes.setFlow(newNodes);
}
finishFlowAction(); // setFileDirty, enable() and setFocus()
}
/**
* Enables and disables section, enables and disables buttons after content.
*
*/
public void enable() {
// if annotator is primitive disable whole section
if (!isAggregate()) {
upButton.setEnabled(false);
downButton.setEnabled(false);
flowChoiceLabel.setEnabled(false);
flowControllerChoice.setEnabled(false);
enableFlowControllerGUI(false);
} else {
FlowControllerDeclaration fcd = getFlowControllerDeclaration();
enableFlowControllerGUI(null != fcd);
flowControllerChoice.setEnabled(true);
flowChoiceLabel.setEnabled(true);
int items = flowList.getItemCount();
int selection = flowList.getSelectionIndex();
if (items == 0 || selection == -1) {
editor.getAggregatePage().getAggregateSection().getRemoveFromFlowButton().setEnabled(false);
upButton.setEnabled(false);
downButton.setEnabled(false);
} else {
editor.getAggregatePage().getAggregateSection().getRemoveFromFlowButton().setEnabled(true);
// disable if first item is selected
upButton.setEnabled(!(selection == 0));
// disable if last item is selected
downButton.setEnabled(!(selection == items - 1));
}
}
}
/**
* Proofs if a node is contained in the list of nodes
*
* @param node
* @return whether the node is in the list or not
*/
public boolean containsNode(String node) {
String[] nodes = new FlowNodes(getModelFlow()).getFlow();
if (null == nodes)
return false;
for (int i = 0; i < nodes.length; i++) {
if (node.equals(nodes[i]))
return true;
}
return false;
}
/**
* @return
*/
public Button getDownButton() {
return downButton;
}
/**
* @return
*/
public Table getFlowList() {
return flowList;
}
/**
* @return
*/
public Button getUpButton() {
return upButton;
}
public void removeAll() {
FlowConstraints flow = getModelFlow();
if (flow != null) {
flow.setAttributeValue("fixedFlow", new String[0]); //$NON-NLS-1$
editor.setFileDirty();
editor.getAggregatePage().getAggregateSection().refresh();
}
}
private static final String[] flowControllerHeadersLC = new String[] { "<flowcontrollerdescription" }; // don't
// end
// in a
// blank
// -
// could
// mismatch
// a
// cr/lf
private void handleFindFlowController() {
FindComponentDialog dialog1 = new FindComponentDialog(this, "Find a Flow Controller",
"Specify a name pattern and/or other constraints, and then push the Search button",
flowControllerHeadersLC);
if (Window.CANCEL == dialog1.open())
return;
List matchingDelegateComponentDescriptors = dialog1.getMatchingDelegateComponentDescriptors();
List matchingDelegateComponentDescriptions = dialog1.getMatchingDelegateComponentDescriptions();
if (matchingDelegateComponentDescriptors.size() == 0) {
Utility.popMessage("No matching Components",
"There are no Components matching your search criteria.", MessageDialog.ERROR);
return;
}
PickTaeForTypesDialog dialog2 = new PickTaeForTypesDialog(this, editor.getFile().getName(),
matchingDelegateComponentDescriptors, matchingDelegateComponentDescriptions);
if (Window.CANCEL == dialog2.open())
return;
String[] selectedDelegateComponentDescriptors = dialog2
.getSelectedDelegateComponentDescriptors();
if (selectedDelegateComponentDescriptors == null
|| selectedDelegateComponentDescriptors.length == 0) {
return;
}
if (checkForOneSelection(selectedDelegateComponentDescriptors.length)) {
String fileName = selectedDelegateComponentDescriptors[0].replace('\\', '/');
int nLastSlashLoc = fileName.lastIndexOf('/');
String shortName;
if (nLastSlashLoc == -1) {
shortName = fileName;
} else {
shortName = fileName.substring(nLastSlashLoc + 1);
}
produceKeyAddFlowController(shortName,
editor.getFullPathFromDescriptorRelativePath(fileName), dialog2.isImportByName);
}
}
private void produceKeyAddFlowController(String shortName, String fullPathFileName,
boolean isImportByName) {
Import imp = createImport(fullPathFileName, isImportByName);
// key is shortName plus a suffix if needed to make it unique.
// The set of existing keys is obtained from the model,
// not from the GUI table (as was the case in earlier design)
FlowControllerDeclaration oldFcd = getFlowControllerDeclaration();
setFlowControllerDeclaration(null);
String keyName = produceUniqueComponentKey(shortName);
if (null == keyName) {
setFlowControllerDeclaration(oldFcd); // revert
return;
}
XMLizable inputDescription = readImport(imp, fullPathFileName, isImportByName);
if (null == inputDescription) {
setFlowControllerDeclaration(oldFcd); // revert
return;
}
if (!(inputDescription instanceof FlowControllerDescription)) {
Utility.popMessage("Invalid kind of descriptor", MessageFormat.format(
"Operation cancelled: The descriptor ''{0}'' being added is not a FlowController.",
new Object[] { maybeShortenFileName(fullPathFileName) }), MessageDialog.ERROR);
setFlowControllerDeclaration(oldFcd); // revert
return;
}
FlowControllerDeclaration fcd = new FlowControllerDeclaration_impl();
fcd.setKey(keyName);
fcd.setImport(imp);
setFlowControllerDeclaration(fcd);
// before adding the import, see if the merge type system is OK
if (!isValidAggregateChange()) {
setFlowControllerDeclaration(oldFcd); // revert
return;
}
finishAggregateChangeAction();
editor.addDirtyTypeName("<Aggregate>"); // force running jcasgen
refresh(); // refresh every time to capture the order of items added
}
private void handleSpecifyFlowController() {
MultiResourceSelectionDialog dialog = new MultiResourceSelectionDialog(getSection().getShell(),
editor.getFile().getProject().getParent(), "Flow Controller Selection", editor
.getFile().getLocation(), editor);
dialog.setTitle("Flow Controller Selection");
dialog.setMessage("Select a Flow Controller descriptor from the workspace:");
if (Window.CANCEL == dialog.open()) {
return;
}
Object[] files = dialog.getResult();
if (files != null && checkForOneSelection(files.length)) {
FileAndShortName fsn = new FileAndShortName(files[0]);
produceKeyAddFlowController(fsn.shortName, fsn.fileName, dialog.isImportByName);
}
}
private boolean checkForOneSelection(int numberSelected) {
if (numberSelected > 1) {
Utility.popMessage("Error - Multiple selection",
"Only one Flow Controller can be selected. Please try again.", MessageDialog.ERROR);
return false;
}
return true;
}
}