/*
* 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.dde.internal.page;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.Map;
import java.util.TreeMap;
import org.apache.uima.UIMAFramework;
import org.apache.uima.aae.deployment.AEDeploymentConstants;
import org.apache.uima.aae.deployment.AEDeploymentDescription;
import org.apache.uima.aae.deployment.AEService;
import org.apache.uima.aae.deployment.AsyncAEErrorConfiguration;
import org.apache.uima.aae.deployment.AsyncAggregateErrorConfiguration;
import org.apache.uima.aae.deployment.impl.AEDelegates_Impl;
import org.apache.uima.aae.deployment.impl.AEDeploymentMetaData_Impl;
import org.apache.uima.aae.deployment.impl.NameValue;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.dde.internal.DeploymentDescriptorEditor;
import org.apache.uima.dde.internal.Messages;
import org.apache.uima.dde.internal.wizards.EditParamWizard;
import org.apache.uima.resource.ResourceSpecifier;
import org.apache.uima.resource.metadata.Import;
import org.apache.uima.resource.metadata.impl.Import_impl;
import org.apache.uima.taeconfigurator.editors.ui.FileAndShortName;
import org.apache.uima.taeconfigurator.editors.ui.Utility;
import org.apache.uima.taeconfigurator.files.MultiResourceSelectionDialog;
import org.apache.uima.tools.debug.util.Trace;
import org.apache.uima.tools.internal.cde.uima.util.UimaDescriptionUtils;
import org.apache.uima.tools.internal.ui.forms.FormSection;
import org.apache.uima.tools.internal.ui.forms.FormSection2;
import org.apache.uima.util.InvalidXMLException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.fieldassist.DecoratedField;
import org.eclipse.jface.fieldassist.FieldDecoration;
import org.eclipse.jface.fieldassist.FieldDecorationRegistry;
import org.eclipse.jface.viewers.ColumnLayoutData;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Spinner;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.forms.FormColors;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.events.ExpansionAdapter;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.forms.widgets.TableWrapData;
import org.eclipse.ui.forms.widgets.TableWrapLayout;
/**
*
*
*/
public class OverviewPage extends AbstractHeaderPage {
static private final int SERVICE_PANE_INDENT = 8; // indent for elements of service section_
static private final Object[] EMPTY_ARRAY = new Object[0];
private IManagedForm mForm;
private ScrolledForm form;
private DecoratedField brokerUrlDecoField;
private DecoratedField endPointDecoField;
private DecoratedField topDescriptorDecoField;
private FieldDecoration decorationBrokerUrl;
private FieldDecoration decorationEndPoint;
private FieldDecoration decorationTopDescriptor;
private Text brokerUrl;
private Text endPoint;
private Spinner initialFsHeapSize;
private Spinner casPoolSize;
private Spinner prefetch;
private Text topDescriptorField;
private Label importByNameOrLocation;
private boolean isImportByLocation = true; // default
private DeploymentDescriptorEditor multiPageEditor;
private AEDeploymentDescription aeDeploymentDescription;
private AEService aeService;
private Button customButton; // Customization for C++
private Composite customComposite;
private Composite serviceSectionClient;
private Text nameText;
private Text description;
private Text version;
private Text vendor;
private boolean ignoreUpdate = false; // Used to update Text without setting dirty flag
private Action openAction; // Open top-level Xml with CDE
private Action notInWSAction; // Pop-up "File is not in workspace" when try to open
private TableViewer envTableViewer;
private Table envTable;
private Map<String,NameValue> envName2NameValueMap = new TreeMap<String,NameValue>();
private Button addButton;
private Button editButton;
private Button removeButton;
private ColumnLayoutData[] envTableColumnLayouts = {
new ColumnWeightData(200),
new ColumnWeightData(300)
};
/** ********************************************************************** */
// Used by AEMetaDataDetailsPage
public void enableCasPoolSizeSettings (boolean enable) {
casPoolSize.setEnabled(enable);
}
// Used by AEMetaDataDetailsPage
public void setCasPoolSize (int number) {
try {
if (!aeDeploymentDescription.getAeService().getAnalysisEngineDeploymentMetaData().isAsync()) {
casPoolSize.setSelection(number); // Update control
aeDeploymentDescription.setCasPoolSize(number); // Update descriptor
}
} catch (InvalidXMLException e) {
e.printStackTrace();
}
}
/** ********************************************************************** */
/**
* Content provider for the environment var table
*/
protected class EnvVariableContentProvider implements IStructuredContentProvider {
public Object[] getElements(Object inputElement) {
Map<String,NameValue> m = (Map<String,NameValue>) inputElement;
if (!m.isEmpty()) {
return m.values().toArray();
}
return EMPTY_ARRAY;
}
public void dispose() {
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
if (newInput == null || !(newInput instanceof Map)){
return;
}
if (viewer instanceof TableViewer){
TableViewer tableViewer= (TableViewer) viewer;
if (tableViewer.getTable().isDisposed()) {
return;
}
tableViewer.setSorter(new ViewerSorter() {
public int compare(Viewer iviewer, Object e1, Object e2) {
if (e1 == null) {
return -1;
} else if (e2 == null) {
return 1;
} else {
return ((NameValue)e1).getName().compareToIgnoreCase(((NameValue)e2).getName());
}
}
});
}
}
}
/**
* Label provider for the environment var table
*/
public class EnvVariableLabelProvider extends LabelProvider implements ITableLabelProvider {
public String getColumnText(Object element, int columnIndex) {
String result = null;
if (element != null) {
NameValue var = (NameValue) element;
switch (columnIndex) {
case 0: // variable
result = var.getName();
break;
case 1: // value
result = var.getValue();
break;
}
}
return result;
}
public Image getColumnImage(Object element, int columnIndex) {
return null;
}
}
/** ********************************************************************** */
private ModifyListener fModifyListener = new ModifyListener() {
public void modifyText(ModifyEvent e) {
Object source = e.getSource();
if (source == brokerUrl) {
aeService.setBrokerURL(brokerUrl.getText().trim());
} else if (source == endPoint) {
aeService.setEndPoint(endPoint.getText().trim());
} else if (source == topDescriptorField) {
} else if (source == nameText) {
aeDeploymentDescription.setName(nameText.getText().trim());
} else if (source == description) {
aeDeploymentDescription.setDescription(description.getText().trim());
} else if (source == version) {
aeDeploymentDescription.setVersion(version.getText().trim());
} else if (source == vendor) {
aeDeploymentDescription.setVendor(vendor.getText().trim());
}
isValid();
if (!ignoreUpdate) {
multiPageEditor.setFileDirty();
}
}
};
protected SelectionListener selectionListener = new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
if (event.getSource() == casPoolSize) {
aeDeploymentDescription.setCasPoolSize(casPoolSize.getSelection());
} else if (event.getSource() == initialFsHeapSize) {
aeDeploymentDescription.setInitialFsHeapSize(initialFsHeapSize.getSelection());
} else if (event.getSource() == prefetch) {
aeService.setPrefetch(prefetch.getSelection());
} else if (event.getSource() == customButton) {
// Customization of C++
if (customComposite == null) {
aeService.setCustomValue(AEDeploymentConstants.TAG_CUSTOM_ATTR_NAME);
customComposite = createCustomizationSection(serviceSectionClient);
updateEnvironmentVariables();
} else {
aeService.setCustomValue(null);
if (aeService.getEnvironmentVariables() != null) {
aeService.getEnvironmentVariables().clear();
}
customComposite.dispose();
customComposite = null;
}
serviceSectionClient.layout(true, true);
mForm.reflow(true);
}
multiPageEditor.setFileDirty();
}
};
/** ********************************************************************** */
/**
* @param editor
* @param id
* @param title
*/
public OverviewPage(DeploymentDescriptorEditor editor, String id, String title) {
super(editor.cde, id, title);
multiPageEditor = editor;
aeDeploymentDescription = multiPageEditor.getAEDeploymentDescription();
aeService = aeDeploymentDescription.getAeService();
}
/**
* Called by the framework to fill in the contents
*/
protected void createFormContent(IManagedForm managedForm) {
super.createFormContent(managedForm);
mForm = managedForm;
form = managedForm.getForm();
FormToolkit toolkit = managedForm.getToolkit();
form.setText(Messages.DDE_OverviewPage_Title);
ScrolledForm form = managedForm.getForm();
FormColors colors = toolkit.getColors();
colors.initializeSectionToolBarColors();
Color gbg = colors.getColor(FormColors.TB_GBG);
Color bg = colors.getBackground();
form.getForm().setTextBackground(new Color[] { bg, gbg }, new int[] { 100 }, true);
fillBody(managedForm, toolkit);
}
private void fillBody(IManagedForm managedForm, FormToolkit toolkit) {
Composite body = managedForm.getForm().getBody();
body.setLayout(new GridLayout(1, false)); // this is required !
Composite compTop = toolkit.createComposite(body);
compTop.setLayout(new GridLayout(1, false));
compTop.setLayoutData(new GridData(GridData.FILL_BOTH));
Control c = compTop.getParent();
while (!(c instanceof ScrolledComposite)) {
c = c.getParent();
}
((GridData) compTop.getLayoutData()).widthHint = c.getSize().x;
((GridData) compTop.getLayoutData()).heightHint = c.getSize().y;
compTop.setLayoutData(new GridData(GridData.FILL_BOTH)); // needed
ScrolledComposite leftScrolled = new ScrolledComposite(compTop, SWT.H_SCROLL | SWT.V_SCROLL); // toolkit.createComposite(sashFormOverview);
leftScrolled.setExpandHorizontal(true);
leftScrolled.setExpandVertical(true);
leftScrolled.setLayoutData(new GridData(GridData.FILL_BOTH));
leftScrolled.setLayout(new GridLayout(1, false));
Composite servicePane = toolkit.createComposite(leftScrolled);
TableWrapLayout layout = new TableWrapLayout();
servicePane.setLayout(layout);
servicePane.setLayoutData(new GridData(GridData.FILL_BOTH));
leftScrolled.setContent(servicePane);
ScrolledComposite rightScrolled = new ScrolledComposite(compTop, SWT.H_SCROLL | SWT.V_SCROLL); // toolkit.createComposite(sashFormOverview);
rightScrolled.setExpandHorizontal(true);
rightScrolled.setExpandVertical(true);
rightScrolled.setLayoutData(new GridData(GridData.FILL_BOTH));
rightScrolled.setLayout(new GridLayout(1, false));
Composite rightPane = toolkit.createComposite(rightScrolled);
layout = new TableWrapLayout();
rightPane.setLayout(layout);
rightPane.setLayoutData(new GridData(GridData.FILL_BOTH));
rightScrolled.setContent(rightPane);
createIdentitySection(rightPane, toolkit);
createServiceSection(servicePane, toolkit);
leftScrolled.setMinSize(servicePane.computeSize(SWT.DEFAULT, SWT.DEFAULT));
rightScrolled.setMinSize(rightPane.computeSize(SWT.DEFAULT, SWT.DEFAULT));
}
/** ********************************************************************** */
private Section createIdentitySection(Composite parent, FormToolkit toolkit) {
Section section = FormSection.createTableWrapDataSection(toolkit, parent, Section.TREE_NODE,
Messages.DDE_OverviewPage_General_Section_Title,
Messages.DDE_OverviewPage_General_Section_Description, 10, 3, TableWrapData.FILL_GRAB,
TableWrapData.FILL_GRAB, 1, 1);
section.setExpanded(true);
section.addExpansionListener(new ExpansionAdapter() {
public void expansionStateChanged(ExpansionEvent e) {
form.reflow(true);
}
});
// //////////////////
Composite sectionClient = toolkit.createComposite(section);
section.setClient(sectionClient);
TableWrapLayout tl = new TableWrapLayout();
tl.numColumns = 2;
tl.bottomMargin = 6;
sectionClient.setLayout(tl);
// Name
nameText = FormSection.createLabelAndText(toolkit, sectionClient, "Name:",
aeDeploymentDescription.getName(), SWT.WRAP, 10, 0);
// Description
description = FormSection.createLabelAndText(toolkit, sectionClient, "Description:",
aeDeploymentDescription.getDescription(), SWT.V_SCROLL | SWT.MULTI | SWT.WRAP, 10, 60);
version = FormSection.createLabelAndText(toolkit, sectionClient, "Version:",
aeDeploymentDescription.getVersion(), SWT.WRAP, 10, 0);
vendor = FormSection.createLabelAndText(toolkit, sectionClient, "Vendor:",
aeDeploymentDescription.getVendor(), SWT.WRAP, 10, 0);
nameText.addModifyListener(fModifyListener);
description.addModifyListener(fModifyListener);
version.addModifyListener(fModifyListener);
vendor.addModifyListener(fModifyListener);
// ////////////////////////////////////////
toolkit.paintBordersFor(sectionClient);
return section;
} // createIdentitySection
private Composite createCustomizationSection(Composite parent) {
FormToolkit toolkit = mForm.getToolkit();
Composite customComposite = toolkit.createComposite(parent);
TableWrapLayout tl = new TableWrapLayout();
tl.numColumns = 1;
tl.numColumns = 1;
tl.leftMargin = 0;
tl.rightMargin = 0;
tl.topMargin = 0;
tl.bottomMargin = 0;
customComposite.setLayout(tl);
GridData gd = new GridData(GridData.FILL_HORIZONTAL);
gd.horizontalIndent = SERVICE_PANE_INDENT;
gd.grabExcessHorizontalSpace = true;
customComposite.setLayoutData(gd);
envTable = createCustomizationTable(customComposite, toolkit);
envTableViewer = new TableViewer(envTable);
envTableViewer.setContentProvider(new EnvVariableContentProvider());
envTableViewer.setLabelProvider(new EnvVariableLabelProvider());
envTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
// handleTableSelectionChanged(event);
int size = ((IStructuredSelection)event.getSelection()).size();
editButton.setEnabled(size == 1);
removeButton.setEnabled(size > 0);
}
});
envTableViewer.addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
if (!envTableViewer.getSelection().isEmpty()) {
handleEditButton();
}
}
});
envTableViewer.setInput(envName2NameValueMap);
toolkit.paintBordersFor(customComposite);
return customComposite;
} // createCustomizationSection
private Table createCustomizationTable(Composite parent, FormToolkit toolkit) {
Composite tableComposite = toolkit.createComposite(parent, SWT.NONE);
TableWrapData td = new TableWrapData(TableWrapData.FILL_GRAB, TableWrapData.FILL_GRAB);
td.grabHorizontal = true;
td.valign = TableWrapData.FILL;
tableComposite.setLayoutData(td);
GridLayout glayout = new GridLayout();
glayout.marginTop = 0;
glayout.marginLeft = 0;
glayout.numColumns = 3;
tableComposite.setLayout(glayout);
// Add SWT.BORDER style to make table's border visible in Linux
final Table table = toolkit.createTable(tableComposite, SWT.BORDER | SWT.HIDE_SELECTION | SWT.FULL_SELECTION
| SWT.H_SCROLL | SWT.V_SCROLL);
table.setLinesVisible(true);
table.setHeaderVisible(true);
String headers[] = { Messages.DDE_EnvVariable_Table_NAME, Messages.DDE_EnvVariable_Table_VALUE };
TableLayout tableLayout = new TableLayout();
table.setLayout(tableLayout);
for (int i = 0; i < headers.length; i++) {
tableLayout.addColumnData(envTableColumnLayouts[i]);
TableColumn tc = new TableColumn(table, SWT.NONE, i);
tc.setResizable(true);
tc.setText(headers[i]);
}
GridData gd = new GridData(GridData.FILL_BOTH|GridData.VERTICAL_ALIGN_BEGINNING);
gd.horizontalSpan = 2;
gd.heightHint = table.getHeaderHeight() + (table.getItemHeight() * 4); // +1
table.setLayoutData(gd);
createTableButtons(tableComposite, toolkit);
return table;
}
protected void createTableButtons(Composite parent, FormToolkit toolkit) {
// Create button composite
Composite buttonComposite = toolkit.createComposite(parent, SWT.NONE);
GridLayout glayout = new GridLayout();
glayout.marginHeight = 0;
glayout.marginWidth = 0;
glayout.numColumns = 1;
GridData gdata = new GridData(GridData.VERTICAL_ALIGN_BEGINNING | GridData.HORIZONTAL_ALIGN_END);
buttonComposite.setLayout(glayout);
buttonComposite.setLayoutData(gdata);
buttonComposite.setFont(parent.getFont());
createVerticalSpacer(buttonComposite, 1);
/**************************************/
/* Create buttons */
/**************************************/
addButton = createPushButton(buttonComposite, "Add...", null, toolkit);
addButton.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent event) {
handleAddButton();
}
});
editButton = createPushButton(buttonComposite, "Edit...", null, toolkit);
editButton.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent event) {
handleEditButton();
}
});
removeButton = createPushButton(buttonComposite, "Remove", null, toolkit);
removeButton.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent event) {
handleDeleteButton();
}
});
} // createTableButtons
public Button createPushButton(Composite parent, String label, Image image, FormToolkit toolkit) {
Button button = toolkit.createButton(parent, label, SWT.PUSH);
GridData gd = new GridData(GridData.CENTER|GridData.FILL_HORIZONTAL);
button.setLayoutData(gd);
button.setEnabled(true);
return button;
}
/**
* Create some empty space.
*/
protected void createVerticalSpacer(Composite comp, int colSpan) {
Label label = new Label(comp, SWT.NONE);
GridData gd = new GridData();
gd.horizontalSpan = colSpan;
label.setLayoutData(gd);
label.setFont(comp.getFont());
}
private Section createServiceSection(Composite parent, final FormToolkit toolkit) {
Section section = FormSection.createTableWrapDataSection(toolkit, parent, Section.TREE_NODE
| Section.DESCRIPTION, Messages.DDE_OverviewPage_Service_Section_Title,
Messages.DDE_OverviewPage_Service_Section_Description, 10, 3, TableWrapData.FILL_GRAB,
TableWrapData.FILL_GRAB, 1, 1);
section.setExpanded(true);
section.addExpansionListener(new ExpansionAdapter() {
public void expansionStateChanged(ExpansionEvent e) {
form.reflow(true);
}
});
Composite sectionClient = toolkit.createComposite(section);
serviceSectionClient = sectionClient;
GridLayout gl = new GridLayout(1, false);
gl.marginWidth = 0;
sectionClient.setLayout(gl);
section.setClient(sectionClient);
// Top part
Composite topComposite = toolkit.createComposite(sectionClient);
TableWrapLayout tl = new TableWrapLayout();
tl.numColumns = 2;
tl.bottomMargin = 10;
topComposite.setLayout(tl);
GridData gd = new GridData(GridData.FILL_HORIZONTAL);
gd.grabExcessHorizontalSpace = true;
topComposite.setLayoutData(gd);
// <deployment protocol="jms" provider="activemq">
// Note: Need to add SWT.BORDER style to make the border VISIBLE in Linux
brokerUrlDecoField = FormSection2.createLabelAndDecoratedText(toolkit, topComposite,
"Broker URL for input queue:",
aeService.getBrokerURL(), SWT.WRAP | SWT.BORDER, 200, 0, true, 0);
// Create an error decoration
decorationBrokerUrl = FormSection2.registerFieldDecoration("brokerUrl",
"The broker URL cannot be empty");
brokerUrlDecoField.addFieldDecoration(decorationBrokerUrl, SWT.LEFT | SWT.TOP, false);
brokerUrl = (Text) brokerUrlDecoField.getControl();
brokerUrl.setToolTipText("Enter the URL for the input queue");
brokerUrl.addModifyListener(fModifyListener);
// Note: Need to add SWT.BORDER style to make the border VISIBLE in Linux
endPointDecoField = FormSection2.createLabelAndDecoratedText(toolkit, topComposite,
"Name for input queue:", aeService.getEndPoint(), SWT.WRAP | SWT.BORDER, 200, 0, true, 0);
endPoint = (Text) endPointDecoField.getControl();
// ((FormData) endPoint.getLayoutData()).width = 200;
endPoint.setToolTipText("Enter the name for the input queue");
endPoint.addModifyListener(fModifyListener);
decorationEndPoint =
FieldDecorationRegistry.getDefault().getFieldDecoration(FieldDecorationRegistry.DEC_ERROR);
decorationEndPoint.setDescription("The name for the queue cannot be empty");
endPointDecoField.addFieldDecoration(decorationEndPoint, SWT.LEFT | SWT.TOP, false);
// <.. prefetch=="0" /> <!-- optional -->
prefetch = FormSection2.createLabelAndSpinner(toolkit, topComposite,
"Number of requests that might be prefetched:", SWT.BORDER, 0,
Integer.MAX_VALUE, false, FormSection2.MAX_DECORATION_WIDTH);
prefetch.setSelection(aeService.getPrefetch());
prefetch.addSelectionListener(selectionListener);
// <casPool numberOfCASes="3"/> <!-- optional -->
casPoolSize = FormSection2.createLabelAndSpinner(toolkit, topComposite,
"Number of CASes in CAS pool:", SWT.BORDER, 1,
Integer.MAX_VALUE, false, FormSection2.MAX_DECORATION_WIDTH);
casPoolSize.setSelection(aeDeploymentDescription.getCasPoolSize());
casPoolSize.addSelectionListener(selectionListener);
try {
if (!aeDeploymentDescription.getAeService().getAnalysisEngineDeploymentMetaData().isAsync()) {
// Top AE is not Async (it is a UIMA-AS Primitive)
casPoolSize.setEnabled(false);
// Display warning if CAS pool size is not equal to the number of instances
int instances = aeDeploymentDescription.getAeService().getAnalysisEngineDeploymentMetaData().getNumberOfInstances();
if (casPoolSize.getSelection() != instances) {
if (Window.OK == Utility.popOkCancel("Warning - CAS Pool Size", MessageFormat.format(
"The CAS pool size (={0}) is not equal to the number of instances (={1}).\n\n"
+ "Set the CAS pool size to " + instances + "?",
new Object[] { casPoolSize.getSelection(), instances }),
MessageDialog.WARNING)) {
setCasPoolSize(instances);
multiPageEditor.setFileDirty();
}
}
}
} catch (InvalidXMLException e) {
e.printStackTrace();
}
// initialFsHeapSize (default size is 2M)
initialFsHeapSize = FormSection2.createLabelAndSpinner(toolkit, topComposite,
"Initial size of CAS heap (in bytes):", SWT.BORDER, 1,
Integer.MAX_VALUE, false, FormSection2.MAX_DECORATION_WIDTH);
initialFsHeapSize.setSelection(aeDeploymentDescription.getInitialFsHeapSize());
initialFsHeapSize.addSelectionListener(selectionListener);
// ////////////////////////////////////////
// Top descriptor
topDescriptorDecoField = FormSection2.createLabelAndGridLayoutDecoratedContainer(toolkit,
topComposite, "Top analysis engine descriptor", 2, 0, 0);
Composite browsingGroup = (Composite) topDescriptorDecoField.getControl();
decorationTopDescriptor = FormSection2.registerFieldDecoration("topDescriptorField",
"Top descriptor cannot be empty");
topDescriptorDecoField.addFieldDecoration(decorationTopDescriptor, SWT.LEFT | SWT.TOP, false);
toolkit.paintBordersFor(browsingGroup);
topDescriptorField = toolkit.createText(browsingGroup, "", SWT.READ_ONLY);
topDescriptorField.setLayoutData(new GridData(GridData.FILL_HORIZONTAL
| GridData.GRAB_HORIZONTAL));
String topDescriptor = null;
Import imp = aeService.getImportDescriptor();
if (imp != null) {
String descr = imp.getLocation();
if (descr == null) {
isImportByLocation = false;
descr = imp.getName();
} else {
isImportByLocation = true;
}
topDescriptor = descr;
}
topDescriptorField.setText(topDescriptor != null ? topDescriptor : "");
topDescriptorField.addModifyListener(fModifyListener);
// Button for browsing AE Xml descriptor
Button browseDirectoriesButton = toolkit.createButton(browsingGroup, "B&rowse...", SWT.PUSH);
browseDirectoriesButton.setLayoutData(new GridData());
browseDirectoriesButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
MultiResourceSelectionDialog dialog = new MultiResourceSelectionDialog(
form.getShell(), multiPageEditor.getFile().getProject().getParent(),
"Component Engine Selection", multiPageEditor.getFile().getLocation(), multiPageEditor.cde);
dialog.setTitle("Component Engine Selection");
dialog.setMessage("Select one component engine from the workspace:");
dialog.open();
Object[] files = dialog.getResult();
if (files != null && files.length > 0) {
for (int i = 0; i < files.length; i++) {
FileAndShortName fsn = new FileAndShortName(files[i]);
updateTopDescriptor(fsn.fileName, !dialog.isImportByName);
}
}
}
});
topDescriptorField.addTraverseListener(new TraverseListener() {
public void keyTraversed(TraverseEvent e) {
if (e.detail == SWT.TRAVERSE_RETURN) {
e.doit = false;
// updateFileList(inputDocPathField.getText().trim());
}
}
});
topDescriptorField.addFocusListener(new FocusAdapter() {
public void focusLost(org.eclipse.swt.events.FocusEvent e) {
// updateFileList(inputDocPathField.getText().trim());
}
});
createContextMenu();
// Import by Name or by Location
toolkit.createLabel(topComposite, "", SWT.NONE);
Composite nameOrLocation = toolkit.createComposite(topComposite, SWT.NONE);
nameOrLocation.setLayout(new GridLayout(2, false));
TableWrapData td = new TableWrapData();
td.colspan = 1;
td.grabHorizontal = true;
td.indent = 0;
nameOrLocation.setLayoutData(td);
toolkit.paintBordersFor(nameOrLocation);
importByNameOrLocation = FormSection.createLabelAndLabel(toolkit, nameOrLocation, "Import by:",
"(Name or Location)", 200, 20);
if (imp != null) {
if (isImportByLocation) {
importByNameOrLocation.setText("Location");
} else {
importByNameOrLocation.setText("Name");
}
}
// Run C++ component in a separate process
customButton = toolkit.createButton(sectionClient, "Run top level C++ component in a separate process", SWT.CHECK);
gd = new GridData(GridData.FILL_HORIZONTAL);
gd.horizontalIndent = SERVICE_PANE_INDENT;
gd.grabExcessHorizontalSpace = true;
customButton.setLayoutData(gd);
customButton.addSelectionListener(selectionListener);
if (imp != null) {
// Check if C++ AE
customButton.setEnabled(aeService.isCPlusPlusTopAE());
if (aeService.getCustomValue() != null) {
customButton.setSelection(true);
if (aeService.getEnvironmentVariables() != null) {
for (NameValue nv: aeService.getEnvironmentVariables()) {
envName2NameValueMap.put(nv.getName(), nv);
}
customComposite = createCustomizationSection(serviceSectionClient);
}
}
} else {
customButton.setEnabled(false);
}
toolkit.paintBordersFor(topComposite);
return section;
} // createServiceSection
private void createContextMenu() {
// Create Open Action
openAction = new Action(Messages.DDE_POPUP_ACTION_OPEN_IN_NEW_WINDOW) {
public void run() {
multiPageEditor.openTopLevelXmlDescriptor(aeService.getImportDescriptor());
}
};
// Action when trying to open a file outside workspace
notInWSAction = new Action(Messages.DDE_POPUP_ACTION_NOT_IN_WORKSPACE) {
public void run() {
}
};
notInWSAction.setEnabled(false);
// Create menu manager.
MenuManager menuMgr = new MenuManager();
menuMgr.setRemoveAllWhenShown(true);
menuMgr.addMenuListener(new IMenuListener() {
public void menuAboutToShow(IMenuManager mgr) {
fillContextMenu(mgr);
}
});
// Create menu.
Menu menu = menuMgr.createContextMenu(topDescriptorField);
topDescriptorField.setMenu(menu);
// Register menu for extension.
// getSite().registerContextMenu(menuMgr, topDescriptorField);
}
private void fillContextMenu(IMenuManager mgr) {
String xml = topDescriptorField.getText().trim();
if (xml.length() > 0) {
String path = multiPageEditor.cde.getAbsolutePathFromImport(aeService.getImportDescriptor());
IPath iPath = new Path(path);
IFile[] files = multiPageEditor.cde.getProject().getWorkspace().getRoot().findFilesForLocation(iPath);
if (null == files || files.length != 1) {
mgr.add(notInWSAction);
return;
}
mgr.add(openAction);
}
}
/** ********************************************************************** */
protected void updateTopDescriptor(String fileFullPath, boolean byLocation) {
// Import by Location or by Name ?
Import importDescriptor = null;
try {
if (byLocation) {
// Import by Location
importDescriptor = createLocationImport(fileFullPath);
} else {
// Import by Name
importDescriptor = UimaDescriptionUtils.createByNameImport(fileFullPath,
multiPageEditor.cde.createResourceManager());
}
} catch (MalformedURLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
return;
}
aeService.setImportDescriptor(importDescriptor);
String relativeFile = UimaDescriptionUtils.getDescriptorFromImport(importDescriptor);
try {
// Set Async=false (default value) to handle the case of reloading the Top AE's descriptor
aeService.getAnalysisEngineDeploymentMetaData().setAsync(false);
ResourceSpecifier rs = aeService.resolveTopAnalysisEngineDescription(multiPageEditor.cde.createResourceManager(), false);
if (rs != null) {
if (rs instanceof AnalysisEngineDescription) {
AnalysisEngineDescription aed = (AnalysisEngineDescription) rs;
AEDelegates_Impl delegates = new AEDelegates_Impl(aeService
.getAnalysisEngineDeploymentMetaData(multiPageEditor.cde.createResourceManager()));
Map map = aed.getDelegateAnalysisEngineSpecifiers(multiPageEditor.cde.createResourceManager());
for (Object m : map.entrySet()) {
Map.Entry entry = (Map.Entry) m;
// Trace.err("key: " + entry.getKey() + " ; " + entry.getValue().getClass().getName());
AEDeploymentMetaData_Impl meta = new AEDeploymentMetaData_Impl();
meta.setKey((String) entry.getKey());
// Create a new Error Config
if (entry.getValue() instanceof ResourceSpecifier) {
Object obj = UIMAFramework.getResourceSpecifierFactory()
.createObject(AsyncAggregateErrorConfiguration.class);
((AsyncAEErrorConfiguration) obj).getGetMetadataErrors().setTimeout(0);
meta.setAsyncAEErrorConfiguration((AsyncAEErrorConfiguration) obj);
} else {
Trace.bug("ResourceSpecifier == null for " + meta.getKey());
}
delegates.addDelegate(meta);
}
aeService.getAnalysisEngineDeploymentMetaData(multiPageEditor
.cde.createResourceManager()).setDelegates(delegates);
}
// If C++ descriptor, activate C++ settings
updateCPlusPlusSettings ();
} else {
Trace.err("Cannot resolve: " + relativeFile);
}
} catch (InvalidXMLException e) {
// e.printStackTrace();
Utility.popMessage(Messages.getString("InvalidXMLException"), //$NON-NLS-1$
multiPageEditor.cde.getMessagesToRootCause(e), MessageDialog.ERROR);
multiPageEditor.switchToBadSource(true);
return;
}
topDescriptorField.setText(relativeFile);
isImportByLocation = byLocation;
if (isImportByLocation) {
importByNameOrLocation.setText("Location");
} else {
importByNameOrLocation.setText("Name");
}
multiPageEditor.refresh();
multiPageEditor.setFileDirty();
}
/**
* @param location
* @return
* @throws MalformedURLException
*/
public Import createLocationImport(String location) throws MalformedURLException {
String sDescriptorRelativePath = multiPageEditor.cde.getDescriptorRelativePath(location);
// If relative path is not "relative", on Windows might get back
// an absolute path starting with C: or something like it.
// If a path starts with "C:", it must be preceeded by
// file:/ so the C: is not interpreted as a "scheme".
if (sDescriptorRelativePath.indexOf("file:/") == -1 //$NON-NLS-1$
&& sDescriptorRelativePath.indexOf(":/") > -1) { //$NON-NLS-1$
sDescriptorRelativePath = "file:/" + sDescriptorRelativePath; //$NON-NLS-1$
}
Import imp = new Import_impl();
// fails on unix? URL url = new URL("file:/" + getDescriptorDirectory());
// Set relative Path Base
// a version that might work on all platforms
URL url = new File(multiPageEditor.cde.getDescriptorDirectory()).toURL();
((Import_impl) imp).setSourceUrl(url);
imp.setLocation(sDescriptorRelativePath);
return imp;
}
/** ********************************************************************** */
public void setActive(boolean active) {
if (active) {
super.setActive(active);
isValid();
}
}
protected void isValid() {
if (brokerUrl.getText().trim().length() == 0) {
showStatus("The queue Broker Url is not specified", IMessageProvider.ERROR);
brokerUrlDecoField.showDecoration(decorationBrokerUrl);
// return;
} else {
brokerUrlDecoField.hideDecoration(decorationBrokerUrl);
}
if (endPoint.getText().trim().length() == 0) {
showStatus("The queue name is not specified", IMessageProvider.ERROR);
endPointDecoField.showDecoration(decorationEndPoint);
// return;
} else {
endPointDecoField.hideDecoration(decorationEndPoint);
}
if (topDescriptorField.getText().trim().length() == 0) {
showStatus("The top-level analysis engine is not specified", IMessageProvider.ERROR);
topDescriptorDecoField.showDecoration(decorationTopDescriptor);
// return;
} else {
topDescriptorDecoField.hideDecoration(decorationTopDescriptor);
}
// showStatus(null, IMessageProvider.ERROR);
}
protected void showStatus(String msg, int msgType) {
// Message.setMessage(form.getForm(), msg, msgType);
}
static public int validateFilePath(String filePath) {
String path = filePath == null ? "" : filePath.trim();
if (path.length() > 0) {
File f = new File(path);
if (f.exists() && f.isFile()) {
return STATUS_IS_VALID;
}
// setErrorMessage("Working directory does not exist");
return STATUS_FILE_NOT_EXIST;
} else if (path.length() == 0) {
return STATUS_FILE_NOT_SPECIFIED;
}
return STATUS_IS_VALID;
}
public void setInput (AEDeploymentDescription aeDD) {
ignoreUpdate = true;
aeDeploymentDescription = aeDD;
aeService = aeDeploymentDescription.getAeService();
nameText.setText(aeDeploymentDescription.getName());
description.setText(aeDeploymentDescription.getDescription());
version.setText(aeDeploymentDescription.getVersion());
vendor.setText(aeDeploymentDescription.getVendor());
brokerUrl.setText(aeService.getBrokerURL());
endPoint.setText(aeService.getEndPoint());
prefetch.setSelection(aeService.getPrefetch());
casPoolSize.setSelection(aeDeploymentDescription.getCasPoolSize());
initialFsHeapSize.setSelection(aeDeploymentDescription.getInitialFsHeapSize());
String topDescriptor = null;
Import imp = aeService.getImportDescriptor();
if (imp != null) {
isImportByLocation = true;
String descr = imp.getLocation();
if (descr == null) {
isImportByLocation = false;
descr = imp.getName();
}
topDescriptor = descr;
if (isImportByLocation) {
importByNameOrLocation.setText("Location");
} else {
importByNameOrLocation.setText("Name");
}
// Check if C++ AE
updateCPlusPlusSettings ();
} else {
// Import is NOT defined
importByNameOrLocation.setText("(Name or Location)");
}
topDescriptorField.setText(topDescriptor != null ? topDescriptor : "");
ignoreUpdate = false;
}
/***************************************************************************/
/**
* Creates an editor for the value of the selected environment variable.
*/
private void handleEditButton() {
IStructuredSelection sel= (IStructuredSelection) envTableViewer.getSelection();
NameValue var= (NameValue) sel.getFirstElement();
if (var == null) {
return;
}
String oldName = var.getName();
EditParamWizard wizard = new EditParamWizard(Messages.DDE_EnvVariable_Wizard_EDIT_Title,
Messages.DDE_EnvVariable_Wizard_EDIT_Description, var.getName(), var.getValue());
WizardDialog dialog = new WizardDialog(form.getShell(), wizard);
if (dialog.open() != Window.OK) {
return;
}
String name = wizard.getName();
String value = wizard.getValue();
// Delete OLD name/value from Map
envName2NameValueMap.remove(oldName);
if (name.length() == 0) {
// Delete OLD name/value from Table
envTableViewer.remove(var);
envTableViewer.refresh();
updateEnvironmentVariables ();
return;
}
if (!oldName.equals(name)) {
envTableViewer.remove(var);
var = new NameValue(name, value);
addAndCheckVariable(var);
} else {
var.setValue(value);
envTableViewer.update(var, null);
}
envName2NameValueMap.put(name, var);
updateEnvironmentVariables ();
}
private void handleAddButton () {
EditParamWizard wizard = new EditParamWizard(Messages.DDE_EnvVariable_Wizard_ADD_Title,
Messages.DDE_EnvVariable_Wizard_ADD_Description, "", "");
WizardDialog dialog = new WizardDialog(form.getShell(), wizard);
if (dialog.open() != Window.OK) {
return;
}
String name = wizard.getName();
String value = wizard.getValue();
if (name.length() == 0) {
return;
}
NameValue nv = new NameValue(name, value);
addAndCheckVariable(nv);
envName2NameValueMap.put(name, nv);
updateEnvironmentVariables ();
}
private void handleDeleteButton() {
IStructuredSelection sel= (IStructuredSelection) envTableViewer.getSelection();
NameValue var= (NameValue) sel.getFirstElement();
if (var == null) {
return;
}
envName2NameValueMap.remove(var.getName());
envTableViewer.remove(var);
envTableViewer.refresh();
updateEnvironmentVariables ();
}
protected boolean addAndCheckVariable(NameValue variable) {
String name= variable.getName();
TableItem[] items = envTableViewer.getTable().getItems();
for (int i = 0; i < items.length; i++) {
NameValue existingVariable = (NameValue) items[i].getData();
// Duplicate name ?
if (existingVariable.getName().equals(name)) {
envTableViewer.remove(existingVariable);
break;
}
}
envTableViewer.add(variable);
return true;
}
// TODO Need to optimize
protected void updateEnvironmentVariables () {
aeService.getEnvironmentVariables().clear();
for (NameValue nv: envName2NameValueMap.values()) {
aeService.getEnvironmentVariables().add(nv);
}
}
/**
* Enable C++ settings if top-level AE is C++
*
* @return void
*/
protected void updateCPlusPlusSettings () {
if (aeService.isCPlusPlusTopAE()) {
customButton.setEnabled(true);
if (aeService.getCustomValue() != null) {
customButton.setSelection(true);
envName2NameValueMap.clear();
if (aeService.getEnvironmentVariables() != null) {
for (NameValue nv: aeService.getEnvironmentVariables()) {
envName2NameValueMap.put(nv.getName(), nv);
}
}
if (customComposite == null) {
customComposite = createCustomizationSection(serviceSectionClient);
} else {
envTableViewer.setInput(envName2NameValueMap);
// envTableViewer.refresh();
}
serviceSectionClient.layout(true, true);
mForm.reflow(true);
} else {
customButton.setSelection(false);
// Clear Env vars
if (aeService.getEnvironmentVariables() != null) {
aeService.getEnvironmentVariables().clear();
}
if (customComposite != null) {
customComposite.dispose();
customComposite = null;
}
}
} else {
customButton.setSelection(false);
customButton.setEnabled(false);
aeService.setCustomValue(null);
if (aeService.getEnvironmentVariables() != null) {
aeService.getEnvironmentVariables().clear();
}
if (customComposite != null) {
customComposite.dispose();
customComposite = null;
}
}
}
}