/*******************************************************************************
* 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.handlers;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jubula.client.core.agent.AutAgentRegistration;
import org.eclipse.jubula.client.core.businessprocess.ObjectMappingEventDispatcher;
import org.eclipse.jubula.client.core.events.DataEventDispatcher;
import org.eclipse.jubula.client.core.events.DataEventDispatcher.OMState;
import org.eclipse.jubula.client.core.events.DataEventDispatcher.ServerState;
import org.eclipse.jubula.client.core.model.IAUTMainPO;
import org.eclipse.jubula.client.core.model.IObjectMappingAssoziationPO;
import org.eclipse.jubula.client.core.model.IObjectMappingCategoryPO;
import org.eclipse.jubula.client.core.persistence.GeneralStorage;
import org.eclipse.jubula.client.ui.constants.Constants;
import org.eclipse.jubula.client.ui.rcp.Plugin;
import org.eclipse.jubula.client.ui.rcp.controllers.TestExecutionContributor;
import org.eclipse.jubula.client.ui.rcp.controllers.dnd.objectmapping.OMEditorDndSupport;
import org.eclipse.jubula.client.ui.rcp.editors.ObjectMappingMultiPageEditor;
import org.eclipse.jubula.client.ui.rcp.handlers.open.AbstractOpenHandler;
import org.eclipse.jubula.client.ui.rcp.i18n.Messages;
import org.eclipse.jubula.client.ui.rcp.utils.Utils;
import org.eclipse.jubula.client.ui.utils.ErrorHandlingUtil;
import org.eclipse.jubula.client.ui.utils.JobUtils;
import org.eclipse.jubula.tools.internal.constants.StringConstants;
import org.eclipse.jubula.tools.internal.exception.CommunicationException;
import org.eclipse.jubula.tools.internal.exception.JBException;
import org.eclipse.jubula.tools.internal.messagehandling.MessageIDs;
import org.eclipse.jubula.tools.internal.registration.AutIdentifier;
import org.eclipse.ui.IEditorPart;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Handler for starting the Object Mapping Mode
*
* @author BREDEX GmbH
* @created Mar 2, 2010
*/
public class StartObjectMappingModeHandler extends AbstractRunningAutHandler {
/** ID of command parameter for Running AUT to connect to for mapping */
public static final String RUNNING_AUT =
"org.eclipse.jubula.client.ui.rcp.commands.OMStartMappingModeCommand.parameter.runningAut"; //$NON-NLS-1$
/** the logger */
private static final Logger LOG =
LoggerFactory.getLogger(StartObjectMappingModeHandler.class);
/**
* Job that performs the actual starting of the Object Mapping Mode.
*
* @author BREDEX GmbH
* @created Mar 18, 2010
*/
private static class StartObjectMappingModeJob extends Job {
/** the editor associated with the Object Mapping Mode activation */
private ObjectMappingMultiPageEditor m_editor;
/**
* the ID of the Running AUT associated with the ObjectMapping Mode
* activation
*/
private AutIdentifier m_autId;
/** the code for the modifier key(s) used to collect UI Elements */
private int m_modifier;
/** the code for the key used to collect UI Elements */
private int m_key;
/** the code for the modifier key(s) used to collect UI Elements and their parents */
private int m_modifierWithParents;
/** the code for the key used to collect UI Elements and their parents */
private int m_keyWithParents;
/** the category into which collected UI Elements will be collected */
private IObjectMappingCategoryPO m_category;
/**
* the type of input action that will collect a UI Element
*
* @see {@link org.eclipse.jubula.tools.internal.constants.InputConstants}
*/
private int m_type;
/**
* the type of input action that will collect a UI Element and its parents
*
* @see {@link org.eclipse.jubula.tools.internal.constants.InputConstants}
*/
private int m_typeWithParents;
/**
* Constructor
*
* @param editor The editor associated with the Object Mapping Mode
* activation.
* @param autId The ID of the Running AUT associated with the
* Object Mapping Mode activation.
* @param modifier The code for the modifier key(s) used to collect
* UI Elements.
* @param key The code for the key used to collect UI Elements.
* @param category The category into which collected UI Elements will
* be collected.
* @param type The type of input action that will collect a UI Element.
* @param modifierWP The code for the modifier key(s) used to collect
* UI Elements and their parents.
* @param keyWP The code for the key used to collect UI Elements
* and their parents.
* @param typeWP The type of input action that will collect a UI Element
* and its parents.
* @see {@link org.eclipse.jubula.tools.internal.constants.InputConstants}
*/
public StartObjectMappingModeJob(ObjectMappingMultiPageEditor editor,
AutIdentifier autId, int modifier, int key,
IObjectMappingCategoryPO category, int type,
int modifierWP, int keyWP, int typeWP) {
super("Start Object Mapping Mode"); //$NON-NLS-1$
m_editor = editor;
m_autId = autId;
m_modifier = modifier;
m_key = key;
m_category = category;
m_type = type;
m_modifierWithParents = modifierWP;
m_keyWithParents = keyWP;
m_typeWithParents = typeWP;
}
/**
*
* {@inheritDoc}
*/
public IStatus run(IProgressMonitor monitor) {
try {
TestExecutionContributor.getInstance()
.getClientTest().startObjectMapping(
m_autId, m_modifier, m_key, m_type,
m_modifierWithParents, m_keyWithParents,
m_typeWithParents);
DataEventDispatcher.getInstance()
.fireOMStateChanged(OMState.running);
DataEventDispatcher.getInstance()
.fireOMAutChanged(m_autId);
ObjectMappingEventDispatcher.setCategoryToCreateIn(
m_category);
m_editor.getOmEditorBP().setCategoryToCreateIn(m_category);
} catch (CommunicationException ce) {
LOG.error(Messages.ErrorStartingObjectMappingMode, ce);
}
return Status.OK_STATUS;
}
/**
* {@inheritDoc}
*/
public boolean belongsTo(Object family) {
if (family instanceof StartObjectMappingModeHandler) {
return true;
}
return super.belongsTo(family);
}
}
/**
*
* {@inheritDoc}
*/
public Object executeImpl(ExecutionEvent event) {
AutIdentifier runningAut = getRunningAut(event, RUNNING_AUT);
IAUTMainPO mappingAut = AutAgentRegistration.getAutForId(
runningAut, GeneralStorage.getInstance().getProject());
ObjectMappingMultiPageEditor omEditor = null;
if (!(Plugin.getActiveEditor() instanceof ObjectMappingMultiPageEditor)
&& Utils.getEditorByPO(mappingAut) != null) {
IEditorPart toActivate = Utils.getEditorByPO(mappingAut);
toActivate.getSite().getPage().activate(toActivate);
if (toActivate instanceof ObjectMappingMultiPageEditor) {
omEditor = (ObjectMappingMultiPageEditor)toActivate;
}
}
if (omEditor == null) {
AbstractOpenHandler.openEditor(mappingAut);
IEditorPart activeEditor = Plugin.getActiveEditor();
if (activeEditor instanceof ObjectMappingMultiPageEditor) {
omEditor = (ObjectMappingMultiPageEditor)activeEditor;
}
}
if (omEditor == null) {
if (runningAut == null) {
LOG.error(Messages.CouldNotOpenOMEditorNoAUT);
} else {
LOG.error(Messages.CouldNotOpenOMEditorForAUT
+ StringConstants.COLON + StringConstants.SPACE
+ runningAut.getExecutableName());
}
AbstractRunningAutHandler.setLastAutID(RUNNING_AUT, null);
return null;
}
AbstractRunningAutHandler.setLastAutID(RUNNING_AUT, runningAut);
IObjectMappingCategoryPO unMappedTech =
omEditor.getAut().getObjMap().getUnmappedTechnicalCategory();
// FIXME zeb: necessary to have this here until our
// command/event/enablement story is more stable
// (it prevents clicking multiple times on the
// "Start Object Mapping Mode" button)
DataEventDispatcher.getInstance().fireAutServerConnectionChanged(
ServerState.Connecting);
startMappingMode(runningAut, omEditor, unMappedTech);
return null;
}
/**
* @param autId The ID of the AUT for which to start the
* Object Mapping Mode.
* @param editor the actual om-editor
* @param unmappedTechNames the top-level category for unmapped
* Technical Names
*/
private void startMappingMode(AutIdentifier autId,
ObjectMappingMultiPageEditor editor,
IObjectMappingCategoryPO unmappedTechNames) {
IObjectMappingCategoryPO category = null;
TreeViewer treeViewer = editor.getTreeViewer();
if (treeViewer != null && ((treeViewer.getSelection()
instanceof IStructuredSelection)
|| (treeViewer.getContentProvider()
instanceof ITreeContentProvider))) {
IStructuredSelection selection = (IStructuredSelection) treeViewer
.getSelection();
Object node;
if (selection.size() == 1) {
node = selection.getFirstElement();
if (node instanceof IObjectMappingCategoryPO
&& OMEditorDndSupport.getSection(
(IObjectMappingCategoryPO) node).equals(
unmappedTechNames)) {
category = (IObjectMappingCategoryPO) node;
} else if (node instanceof IObjectMappingAssoziationPO
&& OMEditorDndSupport.getSection(
(IObjectMappingAssoziationPO) node).equals(
unmappedTechNames)) {
category = ((IObjectMappingAssoziationPO) node)
.getCategory();
}
if (category != null) {
editor.getOmEditorBP().setCategoryToCreateIn(category);
} else {
ObjectMappingEventDispatcher.setCategoryToCreateIn(null);
}
}
}
if (!AutAgentRegistration.getInstance().getRegisteredAuts()
.contains(autId)) {
String message = Messages.OMStartMappingModeActionError1;
ErrorHandlingUtil.createMessageDialog(new JBException(message,
MessageIDs.E_UNEXPECTED_EXCEPTION), null, new String[]{
message});
} else {
IPreferenceStore preferenceStore = Plugin.getDefault()
.getPreferenceStore();
int mappingMod = preferenceStore.getInt(
Constants.MAPPING_MOD_KEY);
int mappingKey = preferenceStore.getInt(
Constants.MAPPING_TRIGGER_KEY);
int mappingType = preferenceStore
.getInt(Constants.MAPPING_TRIGGER_TYPE_KEY);
int mappingWPMod = preferenceStore.getInt(
Constants.MAPPING_WITH_PARENTS_MOD_KEY);
int mappingWPKey = preferenceStore.getInt(
Constants.MAPPING_WITH_PARENTS_TRIGGER_KEY);
int mappingWPType = preferenceStore
.getInt(Constants.MAPPING_WITH_PARENTS_TRIGGER_TYPE_KEY);
final String toolkit = editor.getAut().getToolkit();
Job startObjectMappingModeJob = new StartObjectMappingModeJob(
editor, autId, mappingMod, mappingKey, category,
mappingType, mappingWPMod, mappingWPKey, mappingWPType);
startObjectMappingModeJob.setSystem(true);
JobUtils.executeJob(startObjectMappingModeJob, null);
}
}
/** {@inheritDoc} */
protected String getKey() {
return RUNNING_AUT;
}
}