/*******************************************************************************
* Copyright (c) 2004, 2010 BREDEX GmbH.
* 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:
* BREDEX GmbH - initial API and implementation and/or initial documentation
*******************************************************************************/
package org.eclipse.jubula.client.ui.rcp.widgets.autconfig;
import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.jubula.client.core.agent.AutAgentRegistration;
import org.eclipse.jubula.client.core.events.DataEventDispatcher;
import org.eclipse.jubula.client.internal.AutAgentConnection;
import org.eclipse.jubula.client.internal.exceptions.ConnectionException;
import org.eclipse.jubula.client.ui.constants.Constants;
import org.eclipse.jubula.client.ui.constants.ContextHelpIds;
import org.eclipse.jubula.client.ui.rcp.Plugin;
import org.eclipse.jubula.client.ui.rcp.businessprocess.ConnectAutAgentBP;
import org.eclipse.jubula.client.ui.rcp.dialogs.NagDialog;
import org.eclipse.jubula.client.ui.rcp.dialogs.RemoteFileBrowserDialog;
import org.eclipse.jubula.client.ui.rcp.i18n.Messages;
import org.eclipse.jubula.client.ui.rcp.provider.ControlDecorator;
import org.eclipse.jubula.client.ui.rcp.utils.AutAgentManager;
import org.eclipse.jubula.client.ui.rcp.utils.AutAgentManager.AutAgent;
import org.eclipse.jubula.client.ui.rcp.utils.DialogStatusParameter;
import org.eclipse.jubula.client.ui.rcp.utils.RemoteFileStore;
import org.eclipse.jubula.client.ui.rcp.utils.Utils;
import org.eclipse.jubula.client.ui.rcp.widgets.FileDirectoryBrowser;
import org.eclipse.jubula.client.ui.rcp.widgets.FileDirectoryBrowser.IFileDirectorySelectionListener;
import org.eclipse.jubula.client.ui.utils.DialogUtils;
import org.eclipse.jubula.client.ui.utils.ErrorHandlingUtil;
import org.eclipse.jubula.client.ui.utils.LayoutUtil;
import org.eclipse.jubula.client.ui.widgets.DirectCombo;
import org.eclipse.jubula.client.ui.widgets.UIComponentHelper;
import org.eclipse.jubula.toolkit.common.monitoring.MonitoringAttribute;
import org.eclipse.jubula.toolkit.common.monitoring.MonitoringRegistry;
import org.eclipse.jubula.tools.internal.constants.AutConfigConstants;
import org.eclipse.jubula.tools.internal.constants.EnvConstants;
import org.eclipse.jubula.tools.internal.constants.MonitoringConstants;
import org.eclipse.jubula.tools.internal.constants.StringConstants;
import org.eclipse.jubula.tools.internal.exception.Assert;
import org.eclipse.jubula.tools.internal.i18n.I18n;
import org.eclipse.jubula.tools.internal.messagehandling.MessageIDs;
import org.eclipse.jubula.tools.internal.registration.AutIdentifier;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
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.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.PreferencesUtil;
import org.eclipse.ui.internal.about.AboutUtils;
/**
* @author BREDEX GmbH
* @created Sep 12, 2007
*
*/
public abstract class AutConfigComponent extends ScrolledComposite {
/** layout for buttons */
public static final GridData BUTTON_LAYOUT;
/** number of columns for layout purposes */
public static final int NUM_COLUMNS = 3;
/** the number of lines in a text field */
protected static final int COMPOSITE_WIDTH = 250;
static {
BUTTON_LAYOUT = new GridData();
BUTTON_LAYOUT.horizontalAlignment = GridData.FILL;
BUTTON_LAYOUT.grabExcessHorizontalSpace = true;
}
/**
* This private inner class contains a new ModifyListener.
*
* @author BREDEX GmbH
* @created 22.11.2006
*/
private class WidgetModifyListener implements ModifyListener {
/**
* {@inheritDoc}
*/
@SuppressWarnings("synthetic-access")
public void modifyText(ModifyEvent e) {
Object source = e.getSource();
boolean checked = false;
if (source.equals(m_autConfigNameTextField)) {
checked = true;
} else if (source.equals(m_autIdTextField)) {
checked = true;
} else if (source.equals(m_autWorkingDirectoryTextField)) {
checked = true;
}
if (checked) {
checkAll();
return;
}
Assert.notReached(Messages.EventActivatedByUnknownWidget
+ StringConstants.DOT);
}
}
/**
* This private inner class contains a new SelectionListener.
*
* @author BREDEX GmbH
* @created 13.07.2005
*/
private class WidgetSelectionListener implements SelectionListener {
/**
* {@inheritDoc}
*/
@SuppressWarnings("synthetic-access")
public void widgetSelected(SelectionEvent e) {
Object source = e.getSource();
if (source.equals(m_addServerButton)) {
handleAddServerButtonEvent();
return;
} else if (source.equals(m_basicModeButton)
|| source.equals(m_advancedModeButton)
|| source.equals(m_expertModeButton)) {
selectModeButton((Button)source);
return;
} else if (source.equals(m_autWorkingDirectoryButton)) {
if (isRemoteRequest()) {
remoteBrowse(true, AutConfigConstants.WORKING_DIR,
m_autWorkingDirectoryTextField,
Messages.AUTConfigComponentSelectWorkDir);
} else {
DirectoryDialog directoryDialog = new DirectoryDialog(
getShell(), SWT.APPLICATION_MODAL
| SWT.ON_TOP);
handleWorkDirButtonEvent(directoryDialog);
}
return;
}
Assert.notReached(Messages.EventActivatedByUnknownWidget
+ StringConstants.LEFT_PARENTHESIS + source
+ StringConstants.RIGHT_PARENTHESIS + StringConstants.DOT);
}
/**
* {@inheritDoc}
*/
public void widgetDefaultSelected(SelectionEvent e) {
// nothing
}
}
/**
* This private inner class contains a new FileDirectorySelectionListener.
*
* @author BREDEX GmbH
* @created 03.12.2015
*/
private class FileDirectorySelectionListener
implements IFileDirectorySelectionListener {
@Override
public void selectedFileDirectoriesChanged(String keyName,
String value) {
putConfigValue(keyName, value);
}
@Override
public boolean isBrowseable() {
return checkLocalhostServer() || isRemoteRequest();
}
}
/**
* Possible modes for the dialog
*
* @author BREDEX GmbH
* @created Sep 10, 2007
*/
public static enum Mode {
/** basic mode */
BASIC,
/** advanced mode */
ADVANCED,
/** expert mode */
EXPERT
}
/** the current mode */
private Mode m_mode;
/** mapping from mode buttons to modes */
private Map<Button, Mode> m_buttonToModeMap = new HashMap<Button, Mode>();
/** name of the AUT that will be using this configuration */
private String m_autName;
/** if the name of the aut config has been modified from its default */
private boolean m_nameModified;
/** The IAUTConfigPO this component displays/edits */
private Map<String, String> m_autConfig;
/** list of the stored servers */
private AutAgentManager m_listOfServers = AutAgentManager.getInstance();
/** parameter list for callback method of the <code>IDialogStatusListener</code> */
private java.util.List<DialogStatusParameter> m_paramList =
new ArrayList<DialogStatusParameter>();
/** the the WidgetSelectionListener */
private WidgetSelectionListener m_selectionListener;
/** the WidgetModifyListener */
private WidgetModifyListener m_modifyListener;
/** Listener for file or directory selection changes */
private FileDirectorySelectionListener m_fileDirectorySelectionListener;
/** Composite representing the basic area */
private Composite m_basicAreaComposite;
/** Composite representing the advanced area */
private Composite m_advancedAreaComposite;
/** Composite representing the expert area */
private Composite m_expertAreaComposite;
/** Composite representing the monitoring area */
private Composite m_monitoringAreaComposite;
/** Composite holding the entire contents of this config component */
private Composite m_contentComposite;
/** gui component */
private Text m_autConfigNameTextField;
/** gui component */
private Combo m_serverCombo;
/** gui component */
private Button m_addServerButton;
/** gui component */
private Text m_autWorkingDirectoryTextField;
/** gui component */
private Button m_autWorkingDirectoryButton;
/** gui component */
private Label m_autWorkingDirectoryLabel;
/** gui component */
private Text m_autIdTextField;
/** validator for the AUT ID text field */
private IValidator m_autIdValidator;
/** validator for the AUT Config Name text field */
private IValidator m_autConfigNameValidator;
/** The basic mode button. */
private Button m_basicModeButton;
/** The advanced button. */
private Button m_advancedModeButton;
/** The expert mode button. */
private Button m_expertModeButton;
/** Whether the AUT config component supports multiple modes */
private boolean m_isMultiMode;
/** Whether this object has finished initializing */
private boolean m_isinitialized;
/**
* @param parent {@inheritDoc}
* @param style {@inheritDoc}
* @param autConfig data to be displayed/edited
* @param autName the name of the AUT that will be using this configuration.
* @param isMultiMode whether this component supports multiple modes.
*/
public AutConfigComponent(Composite parent, int style,
Map<String, String> autConfig, String autName, boolean isMultiMode) {
super(parent, style);
m_isinitialized = false;
m_autConfig = autConfig;
m_autName = autName;
m_nameModified = !isDataNew(autConfig)
&& autConfig.get(AutConfigConstants.AUT_CONFIG_NAME).equals(
NLS.bind(Messages.AUTConfigComponentDefaultAUTConfigName,
new String [] {
autName,
autConfig.get(AutConfigConstants.
AUT_CONFIG_AUT_HOST_NAME)
}));
m_isMultiMode = isMultiMode;
if (m_isMultiMode) {
IPreferenceStore prefStore = PlatformUI.getPreferenceStore();
String prefMode =
prefStore.getString(Constants.AUT_CONFIG_DIALOG_MODE);
if (prefMode != null && prefMode.length() != 0) {
m_mode = Mode.valueOf(prefMode);
} else {
m_mode = Mode.BASIC;
}
}
createGUI();
populateGUI(autConfig);
init();
if (m_isMultiMode) {
setCurrentMode(m_mode);
} else {
setCompositeVisible(m_basicAreaComposite, true);
}
getDisplay().asyncExec(new Runnable() {
public void run() {
// Since we're resizing after everything is initialized,
// it's possible that the dialog is already disposed here.
if (!isDisposed()) {
resize();
getShell().pack(true);
}
}
});
m_isinitialized = true;
}
/**
* transmits that a Java toolkit is to be used
* @return true if Java toolkit is used
*/
protected boolean isJavaAut() {
return false;
}
/**
* @return the text field for the AUT working directory
*/
protected Text getAutWorkingDirField() {
return m_autWorkingDirectoryTextField;
}
/**
* @return the monitoringAreaComposite
*/
public Composite getMonitoringAreaComposite() {
return m_monitoringAreaComposite;
}
/**
* Populates all areas with data from the given map.
*
* @param data The data to use for population.
*/
private void populateGUI(Map<String, String> data) {
populateBasicArea(data);
populateAdvancedArea(data);
populateExpertArea(data);
populateMonitoringArea(data);
}
/**
* {@inheritDoc}
*/
public void setVisible(boolean visible) {
if (StringConstants.EMPTY.equals(m_autConfigNameTextField.getText())) {
m_autConfigNameTextField.setFocus();
m_autConfigNameTextField.setText(
NLS.bind(Messages.AUTConfigComponentDefaultAUTConfigName,
new String [] {
m_autName,
m_serverCombo.getText()
}));
m_autConfigNameTextField.setSelection(0,
m_autConfigNameTextField.getText().length());
}
}
/**
* @return the AUT-Config-Map
*/
private Map<String, String> getAutConfig() {
return m_autConfig;
}
/** initialize the GUI components */
private void createGUI() {
m_contentComposite = new Composite(this, SWT.NONE);
initGuiLayout(m_contentComposite);
if (m_isMultiMode) {
createModeButtons(m_contentComposite);
}
m_basicAreaComposite = new Composite(m_contentComposite, SWT.NONE);
m_advancedAreaComposite = new Composite(m_contentComposite, SWT.NONE);
m_expertAreaComposite = new Composite(m_contentComposite, SWT.NONE);
m_monitoringAreaComposite = new Composite(
m_contentComposite, SWT.NONE);
createLayout(m_basicAreaComposite);
createLayout(m_advancedAreaComposite);
createLayout(m_expertAreaComposite);
createLayout(m_monitoringAreaComposite);
createBasicArea(m_basicAreaComposite);
createAdvancedArea(m_advancedAreaComposite);
createExpertArea(m_expertAreaComposite);
createMonitoringArea(m_monitoringAreaComposite);
setContent(m_contentComposite);
}
/**
* @param areaComposite The composite for which to create and set a layout.
*/
protected void createLayout(Composite areaComposite) {
areaComposite.setLayout(
createDefaultGridLayout(NUM_COLUMNS));
GridData gridData = new GridData(GridData.BEGINNING);
gridData.horizontalSpan = NUM_COLUMNS;
areaComposite.setLayoutData(gridData);
}
/**
* creates the default GridLayout to be used
* @param numColumns the number of the columns
* @return a new instance of GridLayout
*/
public static GridLayout createDefaultGridLayout(int numColumns) {
GridLayout result = new GridLayout();
result.numColumns = numColumns;
result.horizontalSpacing = 5;
result.verticalSpacing = 5;
result.marginWidth = 0;
result.marginHeight = 0;
return result;
}
/**
* Populates GUI for the advanced configuration section.
*
* @param data Map representing the data to use for population.
*/
protected abstract void populateExpertArea(Map<String, String> data);
/**
* Populates GUI for the advanced configuration section. Subclasses may
* override this empty implementation.
*
* @param data
* Map representing the data to use for population.
*/
protected void populateMonitoringArea(Map<String, String> data) {
// by default do nothing
}
/**
* Populates GUI for the advanced configuration section.
*
* @param data Map representing the data to use for population.
*/
protected abstract void populateAdvancedArea(Map<String, String> data);
/**
* Populates GUI for the basic configuration section.
*
* @param data Map representing the data to use for population.
*/
protected void populateBasicArea(Map<String, String> data) {
fillServerCombo();
if (!isDataNew(data)) {
m_serverCombo.select(m_serverCombo.indexOf(StringUtils
.defaultString(data.get(AutConfigConstants.
AUT_CONFIG_AUT_HOST_NAME))));
m_autConfigNameTextField.setText(StringUtils.defaultString(
data.get(AutConfigConstants.AUT_CONFIG_NAME),
NLS.bind(Messages.AUTConfigComponentDefaultAUTConfigName,
new String [] {
m_autName,
m_serverCombo.getText()
})));
m_autIdTextField.setText(StringUtils.defaultString(
data.get(AutConfigConstants.AUT_ID)));
m_autWorkingDirectoryTextField.setText(StringUtils
.defaultString(data.get(AutConfigConstants.WORKING_DIR)));
} else {
// set some default values
m_serverCombo.select(m_serverCombo.indexOf(StringUtils
.defaultString(EnvConstants.LOCALHOST_ALIAS)));
m_autConfigNameTextField.setText(
NLS.bind(Messages.AUTConfigComponentDefaultAUTConfigName,
new String [] {
m_autName,
m_serverCombo.getText()
}));
}
}
/**
* @param data The map to check.
* @return <code>true</code> if the given map is newly created and defaults
* should be used. Otherwise, <code>false</code>.
*/
protected boolean isDataNew(Map<String, String> data) {
return data == null || data.isEmpty();
}
/**
* @param basicAreaComposite The composite that represents the basic area.
*/
protected void createBasicArea(Composite basicAreaComposite) {
initGUIConfigAndServer(basicAreaComposite);
}
/**
* Create this dialog's advanced area component.
*
* @param advancedAreaComposite Composite representing the advanced area.
*/
protected void createAdvancedArea(Composite advancedAreaComposite) {
setCompositeVisible(advancedAreaComposite, false);
}
/**
* Create this dialog's expert area component.
*
* @param expertAreaComposite Composite representing the expert area.
*/
protected void createExpertArea(Composite expertAreaComposite) {
setCompositeVisible(expertAreaComposite, false);
}
/**
* Create this dialog's monitoring area component
* @param monitoringComposite Composite representing the ccArea
*
*/
protected void createMonitoringArea(Composite monitoringComposite) {
setCompositeVisible(monitoringComposite, true);
}
/**
* Inits the AUT-Configuration and AutAgent area.
*
* @param parent The parent Composite.
*/
private void initGUIConfigAndServer(Composite parent) {
// name property
UIComponentHelper.createLabel(parent, "AUTConfigComponent.configName"); //$NON-NLS-1$
m_autConfigNameTextField = UIComponentHelper.createTextField(parent, 2);
// server chooser
initGuiServerChooser(parent);
// AUT ID field
ControlDecorator.createInfo(
UIComponentHelper.createLabel(parent, "AUTConfigComponent.autId"), //$NON-NLS-1$,
I18n.getString("AUTConfigComponent.autId.helpText"), false); //$NON-NLS-1$
m_autIdTextField = UIComponentHelper.createTextField(parent, 2);
UIComponentHelper.createSeparator(parent, NUM_COLUMNS);
// AUT directory editor
if (!isJavaAut()) {
createAutDirectoryEditor(parent);
}
}
/**
* Inits the AUT working dir area.
*
* @param parent The parent Composite.
*/
protected void createAutDirectoryEditor(Composite parent) {
m_autWorkingDirectoryLabel = UIComponentHelper.createLabel(
parent, "AUTConfigComponent.workDir"); //$NON-NLS-1$
m_autWorkingDirectoryTextField = UIComponentHelper.createTextField(
parent, 1);
m_autWorkingDirectoryButton = new Button(UIComponentHelper
.createLayoutComposite(parent), SWT.PUSH);
m_autWorkingDirectoryButton.setText(Messages.AUTConfigComponentBrowse);
m_autWorkingDirectoryButton.setLayoutData(BUTTON_LAYOUT);
}
/**
*
* @param parent The parent Composite.
*/
private void initGuiServerChooser(Composite parent) {
UIComponentHelper.createLabel(parent, "AUTConfigComponent.server"); //$NON-NLS-1$
m_serverCombo = new Combo(parent, SWT.READ_ONLY);
GridData comboGrid = new GridData(GridData.FILL, GridData.CENTER, true,
false, 1, 1);
LayoutUtil.addToolTipAndMaxWidth(comboGrid, m_serverCombo);
m_serverCombo.setLayoutData(comboGrid);
m_addServerButton = new Button(UIComponentHelper
.createLayoutComposite(parent), SWT.PUSH);
m_addServerButton.setText(Messages.AUTConfigComponentAddServer);
m_addServerButton.setLayoutData(BUTTON_LAYOUT);
}
/**
* Sets the current mode for the dialog (ex. basic, advanced, expert).
*
* @param mode Button representing the mode to activate.
*/
private void setCurrentMode(Mode mode) {
m_basicModeButton.setSelection(false);
m_advancedModeButton.setSelection(false);
m_expertModeButton.setSelection(false);
for (Button key : m_buttonToModeMap.keySet()) {
if (m_buttonToModeMap.get(key) == mode) {
key.setSelection(true);
break;
}
}
IPreferenceStore prefStore = PlatformUI.getPreferenceStore();
if (mode == Mode.BASIC) {
prefStore.setValue(
Constants.AUT_CONFIG_DIALOG_MODE, Mode.BASIC.name());
setCompositeVisible(m_advancedAreaComposite, false);
setCompositeVisible(m_expertAreaComposite, false);
setCompositeVisible(m_monitoringAreaComposite, false);
} else if (mode == Mode.ADVANCED) {
prefStore.setValue(
Constants.AUT_CONFIG_DIALOG_MODE, Mode.ADVANCED.name());
setCompositeVisible(m_advancedAreaComposite, true);
setCompositeVisible(m_expertAreaComposite, false);
setCompositeVisible(m_monitoringAreaComposite, false);
} else if (mode == Mode.EXPERT) {
prefStore.setValue(
Constants.AUT_CONFIG_DIALOG_MODE, Mode.EXPERT.name());
setCompositeVisible(m_advancedAreaComposite, true);
setCompositeVisible(m_expertAreaComposite, true);
setCompositeVisible(m_monitoringAreaComposite, true);
}
resize();
getShell().pack(true);
}
/**
* checks if BASIC mode is selected
* @return mode == BASIC
*/
protected boolean isBasicMode() {
IPreferenceStore prefStore = PlatformUI.getPreferenceStore();
String mode = prefStore.getString(Constants.AUT_CONFIG_DIALOG_MODE);
return mode.equals(Mode.BASIC.name());
}
/**
* Resizes the content composite based on added/removed components.
*/
protected void resize() {
Point newSize =
m_contentComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
m_contentComposite.setSize(newSize);
m_contentComposite.layout();
}
/**
* Sets the visibility of the given composite and adjusts the parent
* layout as necessary. Assumes that the composite is part of a grid layout.
*
* @param composite The composite for which to set the visibility.
* @param visible Whether the composite should be made visible or invisible.
*/
protected void setCompositeVisible(Composite composite, boolean visible) {
composite.setVisible(visible);
((GridData)composite.getLayoutData()).exclude = !visible;
}
/**
* set the layout for the component
* @param comp the composite to set the layout for
*/
private void initGuiLayout(Composite comp) {
GridLayout compositeLayout = new GridLayout();
compositeLayout.numColumns = NUM_COLUMNS;
compositeLayout.horizontalSpacing = LayoutUtil.SMALL_HORIZONTAL_SPACING;
compositeLayout.verticalSpacing = LayoutUtil.SMALL_VERTICAL_SPACING;
compositeLayout.marginHeight = LayoutUtil.SMALL_MARGIN_HEIGHT;
compositeLayout.marginWidth = LayoutUtil.SMALL_MARGIN_WIDTH;
comp.setLayout(compositeLayout);
GridData compositeData = new GridData(SWT.FILL, SWT.FILL, true, true);
compositeData.grabExcessHorizontalSpace = false;
compositeData.grabExcessVerticalSpace = true;
comp.setLayoutData(compositeData);
}
/**
* Fills the server combo box.
*/
private void fillServerCombo() {
boolean checkListeners = m_selectionListener != null;
if (checkListeners) {
deinstallListeners();
}
m_serverCombo.removeAll();
String currentlySelectedServer =
getConfigValue(AutConfigConstants.AUT_CONFIG_AUT_HOST_NAME);
if (currentlySelectedServer != null
&& currentlySelectedServer.trim().length() != 0
&& !m_listOfServers.getAutAgentNames().contains(
currentlySelectedServer)) {
int defaultServerPort =
EnvConstants.AUT_AGENT_DEFAULT_PORT;
m_listOfServers.addServer(
new AutAgentManager.AutAgent(
currentlySelectedServer,
defaultServerPort));
ErrorHandlingUtil.createMessageDialog(
MessageIDs.I_SERVER_NAME_ADDED, null,
new String [] {Messages.ServerName + StringConstants.COLON
+ StringConstants.SPACE + currentlySelectedServer
+ StringConstants.NEWLINE + Messages.ServerPortDefault
+ defaultServerPort});
}
for (String serverName : m_listOfServers.getAutAgentNames()) {
m_serverCombo.add(serverName);
}
if (checkListeners) {
installListeners();
}
}
/**
* Inits the buttons that control the mode (basic, advanced, expert).
*
* @param parent The parent Composite.
*/
protected void createModeButtons(Composite parent) {
Composite modeButtons =
UIComponentHelper.createLayoutComposite(parent, 3);
GridData modeButtonsData = new GridData(GridData.BEGINNING);
modeButtonsData.horizontalSpan = NUM_COLUMNS;
modeButtons.setLayoutData(modeButtonsData);
m_basicModeButton = new Button(modeButtons, SWT.TOGGLE);
m_basicModeButton.setText(Messages.AUTConfigComponentShowBasic);
m_basicModeButton.setSelection(true);
m_buttonToModeMap.put(m_basicModeButton, Mode.BASIC);
m_advancedModeButton = new Button(modeButtons, SWT.TOGGLE);
m_advancedModeButton.setText(Messages.AUTConfigComponentShowAdvanced);
m_buttonToModeMap.put(m_advancedModeButton, Mode.ADVANCED);
m_expertModeButton = new Button(modeButtons, SWT.TOGGLE);
m_expertModeButton.setText(Messages.AUTConfigComponentShowExpert);
m_buttonToModeMap.put(m_expertModeButton, Mode.EXPERT);
}
/**
* installs all listeners to the gui components. All components visualizing
* a property do have some sort of modification listeners which store
* edited data in the edited instance. Some gui components have additional
* listeners for data validation or permission reevaluation.
*/
protected void installListeners() {
WidgetSelectionListener selectionListener = getSelectionListener();
WidgetModifyListener modifyListener = getModifyListener();
if (m_isMultiMode) {
m_basicModeButton.addSelectionListener(selectionListener);
m_advancedModeButton.addSelectionListener(selectionListener);
m_expertModeButton.addSelectionListener(selectionListener);
}
m_addServerButton.addSelectionListener(selectionListener);
m_autConfigNameTextField.addModifyListener(modifyListener);
m_autIdTextField.addModifyListener(modifyListener);
m_autWorkingDirectoryButton.addSelectionListener(selectionListener);
m_autWorkingDirectoryTextField.addModifyListener(modifyListener);
}
/**
* deinstalls all listeners to the gui components. All components visualizing
* a property do have some sort of modification listeners which store
* edited data in the edited instance. Some gui components have additional
* listeners for data validation or permission reevaluation.
*/
protected void deinstallListeners() {
WidgetSelectionListener selectionListener = getSelectionListener();
WidgetModifyListener modifyListener = getModifyListener();
if (m_isMultiMode) {
m_basicModeButton.removeSelectionListener(selectionListener);
m_advancedModeButton.removeSelectionListener(selectionListener);
m_expertModeButton.removeSelectionListener(selectionListener);
}
m_addServerButton.removeSelectionListener(selectionListener);
m_autConfigNameTextField.removeModifyListener(modifyListener);
m_autIdTextField.removeModifyListener(modifyListener);
m_autWorkingDirectoryButton.removeSelectionListener(
selectionListener);
m_autWorkingDirectoryTextField.removeModifyListener(modifyListener);
}
/**
* Maps the given value to the given key for the AUT Configuration. If
* the given key already has a value mapped to it, this value will be
* overwritten.
*
* Updates the enablement of all fields based on the new status of
* the AUT Configuration. Subclasses should extend this method to update the
* fields that they define.
*
* @param key The key for the mapping.
* @param value The value for the mapping.
* @return <code>true</code> if the configuration was changed as a result
* of this method call (i.e. if <code>value</code> was <em>not</em>
* already mapped to <code>key</code>). Otherwise
* <code>false</code>. Note that there is no need to update fields
* if the mapping has not changed.
*/
protected boolean putConfigValue(String key, String value) {
String previousValue =
StringUtils.defaultString(getAutConfig().put(key, value));
boolean wasEmpty = previousValue.length() == 0;
boolean isEmpty = StringUtils.defaultString(value).length() == 0;
boolean areBothEmpty = wasEmpty && isEmpty;
if (isEmpty) {
getAutConfig().remove(key);
}
return (!m_isinitialized && !areBothEmpty)
|| !value.equals(previousValue);
}
/**
*
* @param key The key being searched for in the AUT Configuration.
* @return The value mapped to <code>key</code> in the AUT Configuration.
*/
protected String getConfigValue(String key) {
final String value = getAutConfig().get(key);
return value != null ? value : StringConstants.EMPTY;
}
/**
* Overwrites the AUT Configuration with keys and values from the given
* map.
*
* @param newConfig The new configuration data.
*/
protected void setConfig(Map<String, String> newConfig) {
Utils.makeAutConfigCopy(newConfig, getAutConfig());
}
/**
* Checks whether the currently selected server is localhost. Subclasses
* may extend this method to enable/disable browse buttons.
* @return <code>true</code>, if the currently selected server is localhost
*/
protected boolean checkLocalhostServer() {
boolean enable = isLocalhost();
m_autWorkingDirectoryButton.setEnabled(enable || isRemoteRequest());
return enable;
}
/**
* @return if the current AUT-Agent is localhost
*/
private boolean isLocalhost() {
final InetAddress localHost = EnvConstants.LOCALHOST;
if (localHost == null) {
return false;
}
final String autAgentHostName = getAUTAgentHostNameCombo().getText();
final String canonicalHostName = localHost.getCanonicalHostName();
return (EnvConstants.LOCALHOST_ALIAS.equals(
autAgentHostName.toLowerCase())
|| EnvConstants.LOCALHOST_IP_ALIAS.equals(autAgentHostName)
|| localHost.getHostName().equals(autAgentHostName)
|| localHost.getHostAddress().equals(autAgentHostName)
|| (canonicalHostName != null && canonicalHostName
.equals(autAgentHostName)));
}
/**
* Handles the button event.
*/
public void handleAddServerButtonEvent() {
openServerPrefPage();
}
/**
* The action of the AUT config name field.
* @return <code>null</code> if the new value is valid. Otherwise, returns
* a status parameter indicating the cause of the problem.
*/
public DialogStatusParameter modifyAutConfigFieldAction() {
m_nameModified = !m_autConfigNameTextField.getText().equals(
NLS.bind(Messages.AUTConfigComponentDefaultAUTConfigName,
new String [] {
m_autName,
m_serverCombo.getText()
}));
String newAutConfigNameValue = m_autConfigNameTextField.getText();
DialogStatusParameter error = null;
if (m_autConfigNameValidator != null) {
IStatus validationStatus = m_autConfigNameValidator
.validate(newAutConfigNameValue);
if (!validationStatus.isOK()) {
if (validationStatus.getSeverity() == IStatus.ERROR) {
error = createErrorStatus(validationStatus.getMessage());
} else {
error = createWarningStatus(validationStatus.getMessage());
}
}
}
putConfigValue(AutConfigConstants.AUT_CONFIG_NAME,
m_autConfigNameTextField.getText());
if (!isValid(m_autConfigNameTextField, false)) {
if (m_autConfigNameTextField.getText().length() == 0) {
error = createErrorStatus(
Messages.AUTConfigComponentEmptyAUTConfigName);
} else {
error = createErrorStatus(
Messages.AUTConfigComponentWrongAUTConfigName);
}
}
return error;
}
/**
* The action of the AUT ID field.
* @return <code>null</code> if the new value is valid. Otherwise, returns
* a status parameter indicating the cause of the problem.
*/
public DialogStatusParameter modifyAutIdFieldAction() {
DialogStatusParameter error = null;
String newAutIdValue = m_autIdTextField.getText();
// FIXME zeb This null check is necessary at the moment because the creator
// of AutConfigComponents is in the ToolkitSupport project, which
// is not aware of model (PO) objects nor of databinding classes
// (IValidator). This dependency issue should be resolved, and
// the validator should be set in the constructor, rather than
// in a separate setter method.
if (m_autIdValidator != null) {
IStatus validationStatus = m_autIdValidator.validate(newAutIdValue);
if (!validationStatus.isOK()) {
if (validationStatus.getSeverity() == IStatus.ERROR) {
error = createErrorStatus(validationStatus.getMessage());
} else {
error = createWarningStatus(validationStatus.getMessage());
}
}
}
putConfigValue(AutConfigConstants.AUT_ID, newAutIdValue);
return error;
}
/**
* Opens the server preference page
*/
protected void openServerPrefPage() {
PreferenceDialog dialog = PreferencesUtil.createPreferenceDialogOn(
getShell(), Constants.JB_PREF_PAGE_AUTAGENT, null, null);
DialogUtils.setWidgetNameForModalDialog(dialog);
dialog.open();
m_listOfServers = AutAgentManager.getInstance();
String oldServer = m_serverCombo.getText();
fillServerCombo();
m_serverCombo.setText(oldServer);
}
/**
*
* @return The server selection combo box.
*/
protected Combo getAUTAgentHostNameCombo() {
return m_serverCombo;
}
/**
*
* @return The server list.
*/
protected AutAgentManager getServerList() {
return m_listOfServers;
}
/**
* @param modifiedWidget The modified widget.
* @param emptyAllowed true, if an empty string is allowed as input.
* @return True, if the input of the widget is correct.False, otherwise.
*/
protected boolean isValid(Widget modifiedWidget, boolean emptyAllowed) {
if (modifiedWidget instanceof DirectCombo) {
DirectCombo combo = (DirectCombo)modifiedWidget;
int textLength = combo.getText().length();
String text = combo.getText();
return checkTextInput(emptyAllowed, textLength, text);
}
if (modifiedWidget instanceof Text) {
Text textField = (Text)modifiedWidget;
int textLength = textField.getText().length();
String text = textField.getText();
return checkTextInput(emptyAllowed, textLength, text);
}
return true;
}
/**
* @return true if the AUT config is for the currently connected AUT-Agent
*/
protected boolean isRemoteRequest() {
boolean enable;
try {
final AutAgent currentAUTAgent =
ConnectAutAgentBP.getInstance().getCurrentAutAgent();
if (currentAUTAgent == null) {
return false;
}
if (isLocalhost()) {
return false;
}
final String autAgentHostName = getAUTAgentHostNameCombo()
.getText().toLowerCase();
final InetAddress autAgentHostAddress = InetAddress
.getByName(autAgentHostName);
final String canonicalAUTAgentName =
autAgentHostAddress.getCanonicalHostName().toLowerCase();
final String currentAUTAgentHostName =
currentAUTAgent.getName().toLowerCase();
final InetAddress currentAUTAgentHostAddress =
InetAddress.getByName(currentAUTAgentHostName);
final String canonicalCurrentAUTAgentName =
currentAUTAgentHostAddress.getCanonicalHostName().toLowerCase();
enable = currentAUTAgentHostName
.equals(autAgentHostName)
|| currentAUTAgentHostAddress
.equals(autAgentHostAddress)
|| canonicalCurrentAUTAgentName
.equals(canonicalAUTAgentName);
} catch (UnknownHostException e) {
enable = false;
}
return enable;
}
/**
* @param emptyAllowed true, if an empty string is allowed as input.
* @param textLength the text length
* @param text the text input
* @return true, if text input is validated successful
*/
private boolean checkTextInput(boolean emptyAllowed, int textLength,
String text) {
return !((textLength == 0 && !emptyAllowed)
|| (text.startsWith(" ") || text.endsWith(" "))); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* Notifies the DialogStatusListenerManager about the text input state
*/
private void fireError() {
DataEventDispatcher.getInstance().getDialogStatusListenerMgr()
.fireNotification(m_paramList);
}
/**
* Notifies the DialogStatusListenerManager about the text input state
* @param message The message for the new status.
* @return the new status parameter.
*/
protected DialogStatusParameter createWarningStatus(String message) {
DialogStatusParameter param = new DialogStatusParameter();
param.setButtonState(true);
param.setStatusType(IMessageProvider.WARNING);
param.setMessage(message);
return param;
}
/**
* Notifies the DialogStatusListenerManager about the text input state
* @param message The message for the new status.
* @return the new status parameter.
*/
protected DialogStatusParameter createErrorStatus(String message) {
DialogStatusParameter param = new DialogStatusParameter();
param.setButtonState(false);
param.setStatusType(IMessageProvider.ERROR);
param.setMessage(message);
return param;
}
/**
* Sets no error text / image.
* @param noEntries true if there are neither errors nor warnings
*/
private void setIsValid(boolean noEntries) {
if (noEntries) {
DialogStatusParameter param = new DialogStatusParameter();
param.setButtonState(true);
param.setStatusType(IMessageProvider.NONE);
param.setMessage(Messages.ProjectWizardAUTData);
m_paramList.clear();
m_paramList.add(param);
}
DataEventDispatcher.getInstance().getDialogStatusListenerMgr()
.fireNotification(m_paramList);
}
/**
* @return <code>true</code> if the Aut Config is newly created and defaults
* should be used. Otherwise, <code>false</code>.
*/
protected boolean isConfigNew() {
return m_autConfig == null || m_autConfig.isEmpty();
}
/**
* Enables the given mode button, deselecting all other mode buttons.
*
* @param button The mode button to select.
*/
private void selectModeButton(Button button) {
setCurrentMode(m_buttonToModeMap.get(button));
}
/**
* Inits the state, installs all needed listeners, and performs an initial
* check for validity of all fields.
*/
protected void init() {
initState();
installListeners();
checkAll(m_paramList);
}
/**
* Checks validity of all fields.
*/
public final void checkAll() {
checkAll(m_paramList);
if (m_paramList.isEmpty()) {
setIsValid(true);
} else {
boolean isValid = true;
for (DialogStatusParameter entry : m_paramList) {
if (entry.getStatusType() == IMessageProvider.ERROR) {
isValid = false;
break;
}
}
if (isValid) {
setIsValid(false);
} else {
fireError();
}
}
m_paramList.clear();
}
/**
* Checks validity of all fields. Subclasses should extend this method to
* validate their added fields.
*
* @param paramList A list to which status messages (errors) can be added.
*/
protected void checkAll(java.util.List<DialogStatusParameter> paramList) {
addError(paramList, modifyAutConfigFieldAction());
addError(paramList, modifyAutIdFieldAction());
addError(paramList, modifyServerComboAction());
addError(paramList, modifyWorkingDirFieldAction());
}
/**
* Adds the given error to the list, if the error exists.
*
* @param paramList The list to which the error will be added.
* @param error The error to be added. If this value is <code>null</code>,
* the list is not changed.
*/
protected void addError(List<DialogStatusParameter> paramList,
DialogStatusParameter error) {
if (error != null) {
paramList.add(error);
}
}
/**
*
* @param error Adds an {@link DialogStatusParameter} to the Error list.
*/
protected void addError(DialogStatusParameter error) {
if (error != null) {
m_paramList.add(error);
}
}
/**
* Sets initial editable state for components
*/
protected void initState() {
m_autConfigNameTextField.setEnabled(true);
m_serverCombo.setEnabled(true);
}
/** Handles the server-list event.
* @return False, if the server name combo box contents an error.
*/
public DialogStatusParameter modifyServerComboAction() {
boolean isValid = false;
if (m_serverCombo.getSelectionIndex() != -1) {
putConfigValue(AutConfigConstants.AUT_CONFIG_AUT_HOST_NAME,
m_serverCombo.getItem(
m_serverCombo.getSelectionIndex()));
isValid = true;
}
if (isValid) {
if (!m_nameModified) {
boolean checkListeners = m_selectionListener != null;
if (checkListeners) {
deinstallListeners();
}
m_autConfigNameTextField.setText(
NLS.bind(
Messages.AUTConfigComponentDefaultAUTConfigName,
new String [] {
m_autName,
m_serverCombo.getText()
}));
if (checkListeners) {
installListeners();
}
}
return null;
}
return createErrorStatus(Messages.AUTConfigComponentNoServer);
}
/**
*
* @return the single instance of the selection listener.
*/
@SuppressWarnings("synthetic-access")
private WidgetSelectionListener getSelectionListener() {
if (m_selectionListener == null) {
m_selectionListener = new WidgetSelectionListener();
}
return m_selectionListener;
}
/**
*
* @return the single instance of the modify listener.
*/
@SuppressWarnings("synthetic-access")
private WidgetModifyListener getModifyListener() {
if (m_modifyListener == null) {
m_modifyListener = new WidgetModifyListener();
}
return m_modifyListener;
}
/**
*
* @return the single instance of the file or directory selection listener.
*/
@SuppressWarnings("synthetic-access")
private FileDirectorySelectionListener getFileDirectorySelectionListener() {
if (m_fileDirectorySelectionListener == null) {
m_fileDirectorySelectionListener =
new FileDirectorySelectionListener();
}
return m_fileDirectorySelectionListener;
}
/**
* @return the Text component for the Configuration name.
*/
protected Text getAutConfigNameTextField() {
return m_autConfigNameTextField;
}
/**
* The action of the working directory field.
* @return <code>null</code> if the new value is valid. Otherwise, returns
* a status parameter indicating the cause of the problem.
*/
public DialogStatusParameter modifyWorkingDirFieldAction() {
DialogStatusParameter error = null;
boolean isEmpty =
m_autWorkingDirectoryTextField.getText().length() <= 0;
if (isValid(m_autWorkingDirectoryTextField, true) && !isEmpty) {
if (checkLocalhostServer()) {
File dir = new File(m_autWorkingDirectoryTextField.getText());
if (!dir.isAbsolute()) {
// Start from server dir, rather than client dir
dir = new File("./" + //$NON-NLS-1$
m_autWorkingDirectoryTextField.getText());
}
if (!dir.isDirectory()) {
error = createWarningStatus(
Messages.AUTConfigComponentNoDir);
}
}
} else if (!isEmpty) {
error = createErrorStatus(Messages.AUTConfigComponentWrongWorkDir);
}
putConfigValue(AutConfigConstants.WORKING_DIR,
m_autWorkingDirectoryTextField.getText());
return error;
}
/**
* Hide the working dir GUI column.
*/
protected void hideWorkingDirColumn() {
m_autWorkingDirectoryLabel.setVisible(false);
m_autWorkingDirectoryButton.setVisible(false);
m_autWorkingDirectoryTextField.setVisible(false);
}
/**
*
* @return the text field for the Working Directory.
*/
protected Text getWorkingDirTextField() {
return m_autWorkingDirectoryTextField;
}
/**
* Handles the button event.
* @param directoryDialog The directory dialog.
*/
public void handleWorkDirButtonEvent(DirectoryDialog directoryDialog) {
String directory;
directoryDialog.setMessage(Messages.AUTConfigComponentSelectWorkDir);
File path = new File(m_autWorkingDirectoryTextField.getText());
String filterPath = Utils.getLastDirPath();
if (path.exists()) {
try {
filterPath = path.getCanonicalPath();
} catch (IOException e) {
// Just use the default path which is already set
}
}
directoryDialog.setFilterPath(filterPath);
directory = directoryDialog.open();
if (directory != null) {
m_autWorkingDirectoryTextField.setText(directory);
Utils.storeLastDirPath(directoryDialog.getFilterPath());
putConfigValue(AutConfigConstants.WORKING_DIR,
m_autWorkingDirectoryTextField.getText());
}
}
/**
* handle the browse request
* @param folderSelection true if only folders can be selected
* @param configVarKey key for storing the result
* @param textfield control for visualizing the value
* @param title window title
* @return true if the user selected a new entry and no error occured
*/
protected boolean remoteBrowse(boolean folderSelection,
String configVarKey, Text textfield, String title) {
boolean valueChanged = false;
RemoteFileBrowserDialog directoryDialog = new RemoteFileBrowserDialog(
this.getShell(), false, folderSelection ? IResource.FOLDER
: IResource.FILE);
try {
String oldPath = getConfigValue(configVarKey);
if (oldPath == null || oldPath.length() == 0) {
oldPath = "."; //$NON-NLS-1$
}
RemoteFileStore baseRemoteFS = new RemoteFileStore(
AutAgentConnection.getInstance().getCommunicator(), ".", //$NON-NLS-1$
folderSelection);
StringBuilder modPath = new StringBuilder(oldPath);
baseRemoteFS = handleOldPath(baseRemoteFS, modPath);
directoryDialog.setInput(baseRemoteFS);
directoryDialog.setInitialSelection(new RemoteFileStore(
AutAgentConnection.getInstance().getCommunicator(), oldPath
.toString(), folderSelection));
directoryDialog.setFSRoots(baseRemoteFS.getRootFSs());
directoryDialog.setTitle(title);
directoryDialog.setMessage(
Messages.AUTConfigComponentSelectEntries);
if (directoryDialog.open() == Window.OK) {
final RemoteFileStore resDir = (RemoteFileStore)directoryDialog
.getFirstResult();
if (resDir != null) {
final String path = resDir.getPath();
textfield.setText(path);
putConfigValue(configVarKey,
path);
valueChanged = true;
}
}
} catch (ConnectionException e) {
//FIXME: tobi NLS not found
ErrorDialog.openError(this.getShell(), I18n
.getString("AutConfigComponent.ERROR_TITLE"), null, //$NON-NLS-1$
new Status(IStatus.WARNING, Plugin.PLUGIN_ID, I18n
.getString("AutConfigComponent.ERROR_COMM"))); //$NON-NLS-1$
}
return valueChanged;
}
/**
* check for root entries and modify the necessary values
* @param remoteFS original remote FS
* @param path original path
* @return the original or a new RemoteFileStore if the path begins with
* a root fs entry
*/
private RemoteFileStore handleOldPath(RemoteFileStore remoteFS,
StringBuilder path) {
for (String root : remoteFS.getRootFSs()) {
if (path.toString().startsWith(root)) {
path.delete(0, root.length());
return new RemoteFileStore(remoteFS.getCommunicator(),
root, remoteFS.fetchInfo().isDirectory());
}
}
return remoteFS;
}
/**
* @param validator The validator to set.
*/
// FIXME zeb This method is necessary at the moment because the creator
// of AutConfigComponents is in the ToolkitSupport project, which
// is not aware of model (PO) objects nor of databinding classes
// (IValidator). This dependency issue should be resolved, and
// the validator should be set in the constructor, rather than
// in a separate setter method.
public void setAutIdValidator(IValidator validator) {
m_autIdValidator = validator;
}
/**
* @param validator The validator to set.
*/
public void setAutConfignameValidator(IValidator validator) {
m_autConfigNameValidator = validator;
}
/**
* Creates the label for the monitoring widget
* @param composite The monitoringComposite
* @param attribute The MonitoringAttribute to get the information from
*/
private void createMonitoringWidgetLabel(Composite composite,
MonitoringAttribute attribute) {
Label widgetLabel = UIComponentHelper.createLabelWithText(composite,
attribute.getDescription());
if (!StringUtils.isEmpty(attribute.getInfoBobbleText())) {
ControlDecorator.createInfo(widgetLabel,
attribute.getInfoBobbleText(), false);
}
}
/**
* Dynamically creates GUI components for monitoring composite
* @param monitoringComposite The composite to add the components to
* @param monitoringAttributeList This list contains attributes from the extension point
*
*/
protected void createMonitoringUIComponents(Composite monitoringComposite,
java.util.List<MonitoringAttribute> monitoringAttributeList) {
for (int i = 0; i < monitoringAttributeList.size(); i++) {
final MonitoringAttribute attribute = monitoringAttributeList.
get(i);
if (!attribute.isRender()) {
continue;
}
if (attribute.getType().equalsIgnoreCase(
MonitoringConstants.RENDER_AS_TEXTFIELD)) {
createMonitoringWidgetLabel(monitoringComposite, attribute);
createMonitoringTextFieldWidget(monitoringComposite, attribute);
} else if (attribute.getType().equalsIgnoreCase(
MonitoringConstants.RENDER_AS_FILEBROWSE)) {
createMonitoringWidgetLabel(monitoringComposite, attribute);
createMonitoringMultiFileDirectoryBrowser(monitoringComposite,
attribute, true);
} else if (attribute.getType()
.equalsIgnoreCase(MonitoringConstants.RENDER_AS_CHECKBOX)) {
createMonitoringWidgetLabel(monitoringComposite, attribute);
createMonitoringCheckBoxWidget(monitoringComposite, attribute);
} else if (attribute.getType().equalsIgnoreCase(
MonitoringConstants.RENDER_AS_MULTIDIR_BROWSE)) {
createMonitoringWidgetLabel(monitoringComposite, attribute);
createMonitoringMultiFileDirectoryBrowser(monitoringComposite,
attribute, false);
}
}
}
/**
* Creates a directory and file browser component, where the directories,
* and files can be added, edited and removed
*
* @param composite
* The composite to add the widget on
* @param att
* The current attribute
* @param fileSelectionAllowed
* true, if only file selection is allowed, false if directory
* selection
*/
private void createMonitoringMultiFileDirectoryBrowser(Composite composite,
MonitoringAttribute att, boolean fileSelectionAllowed) {
Composite c = UIComponentHelper.createLayoutComposite(composite);
GridData textGrid = new GridData(GridData.FILL, GridData.CENTER, true,
false, 1, 1);
c.setLayoutData(textGrid);
boolean browseIsEnabled = checkLocalhostServer() || isRemoteRequest();
FileDirectoryBrowser fileDirectoryBrowser = new FileDirectoryBrowser(c,
att.getDescription(), att.getId(), getConfigValue(att.getId()),
att.getExtensionFilters(), fileSelectionAllowed);
fileDirectoryBrowser
.addListModifiedListener(getFileDirectorySelectionListener());
}
/**
* Creates a Checkbox for the given monitoring composite,
* which was specified in the extension point. *
* @param composite The composite to add the widget on
* @param att The current attribute
*
*/
private void createMonitoringCheckBoxWidget(Composite composite,
final MonitoringAttribute att) {
final String autId = getConfigValue(AutConfigConstants.AUT_ID);
final Button b =
UIComponentHelper.createToggleButton(composite, 1);
b.setData(MonitoringConstants.MONITORING_KEY, att.getId());
if (Boolean.parseBoolean(getConfigValue(att.getId()))) {
b.setSelection(true);
}
b.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
showMonitoringInfoDialog(autId);
putConfigValue(att.getId(),
String.valueOf(b.getSelection()));
}
});
}
/**
* creates a Textfield for a given monitoring composite,
* which was specified in the extension point.
* @param composite The monitoring composite
* @param att the MonitoringAttribute
* @return A monitoring textfield
*
*/
private Text createMonitoringTextFieldWidget(Composite composite,
final MonitoringAttribute att) {
final Text textField = UIComponentHelper.createTextField(
composite, 1);
textField.setData(MonitoringConstants.MONITORING_KEY,
att.getId());
textField.setText(getConfigValue(att.getId()));
final IValidator validator = att.getValidator();
textField.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
if (validator != null) {
IStatus status =
validator.validate(textField.getText());
if (!status.isOK()) {
DialogStatusParameter error =
createErrorStatus(status.getMessage());
addError(error);
}
checkAll();
}
putConfigValue(att.getId(), textField.getText());
}
});
final String autId = getConfigValue(AutConfigConstants.AUT_ID);
textField.addFocusListener(new FocusListener() {
private String m_oldText = StringConstants.EMPTY;
public void focusLost(FocusEvent e) {
String currentText = textField.getText();
if (!currentText.equals(m_oldText)) {
showMonitoringInfoDialog(autId);
}
putConfigValue(att.getId(), textField.getText());
}
public void focusGained(FocusEvent e) {
m_oldText = textField.getText();
}
});
return textField;
}
/**
* if monitoring parameters changed, the AUT must be restarted, only than
* the changes will be active. This must be done, because at start up the
* autConfigMap will be stored in the MonitoringDataStore.
*
* @param autId
* The autId
*/
protected void showMonitoringInfoDialog(String autId) {
LinkedList<AutIdentifier> l = (LinkedList<AutIdentifier>)
AutAgentRegistration.getInstance().getRegisteredAuts();
String message = NLS.bind(Messages.ClientMonitoringInfoDialog, autId);
for (AutIdentifier a : l) {
if (a.getExecutableName().equals(autId)) {
NagDialog.runNagDialog(null, message,
ContextHelpIds.AUT_CONFIG_PROP_DIALOG);
}
}
}
/**
* deletes all GUI elements form the given composite.
* @param compostie A Composite from which all gui elements should be deleted
*/
protected void cleanComposite(Composite compostie) {
Control[] ca = compostie.getChildren();
for (int i = 0; i < ca.length; i++) {
ca[i].dispose();
}
resize();
getShell().pack();
}
/**
* Creating an actual monitoring area
*
* @param monitoringComposite
* the composite
*/
protected void createActualMonitoringArea(
Composite monitoringComposite) {
GridLayout result = (GridLayout)monitoringComposite.getLayout();
result.horizontalSpacing = 40;
result.numColumns = 2;
monitoringComposite.setLayout(result);
final String monitoringID = getConfigValue(
AutConfigConstants.MONITORING_AGENT_ID);
if (!StringUtils.isEmpty(monitoringID)) {
IConfigurationElement monitoringExtension =
MonitoringRegistry.getElement(monitoringID);
if (monitoringExtension != null) {
createMonitoringUIComponents(monitoringComposite,
MonitoringRegistry.getAttributes(monitoringExtension));
String extURL = MonitoringRegistry
.getExtUrlForMonitoringId(monitoringID);
if (!StringUtils.isEmpty(extURL)) {
UIComponentHelper.createLabelWithText(monitoringComposite,
Messages.MonitoringAgentAddInfo);
Link extRef = new Link(monitoringComposite, SWT.NONE);
extRef.setText(extURL);
extRef.addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
AboutUtils.openLink(getShell(), event.text);
}
});
}
} else {
StyledText missingExtensionLabel =
new StyledText(monitoringComposite, SWT.WRAP);
missingExtensionLabel.setText(
Messages.MissingMonitoringExtension);
missingExtensionLabel.setEditable(false);
missingExtensionLabel.setEnabled(false);
missingExtensionLabel.setStyleRange(new StyleRange(
0, missingExtensionLabel.getText().length(),
null, null, SWT.ITALIC));
ControlDecorator.createWarning(
missingExtensionLabel,
I18n.getString(
"MissingMonitoringExtension.fieldDecorationText")); //$NON-NLS-1$
}
}
resize();
getShell().pack();
}
}