org.eclipse.jubula.client.ui.rcp.editors.TestJobEditor.java Source code

Java tutorial

Introduction

Here is the source code for org.eclipse.jubula.client.ui.rcp.editors.TestJobEditor.java

Source

/*******************************************************************************
 * 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.editors;

import java.util.Iterator;
import java.util.List;

import org.apache.commons.collections.IteratorUtils;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jubula.client.core.businessprocess.db.TimestampBP;
import org.eclipse.jubula.client.core.events.DataChangedEvent;
import org.eclipse.jubula.client.core.events.DataEventDispatcher;
import org.eclipse.jubula.client.core.events.DataEventDispatcher.DataState;
import org.eclipse.jubula.client.core.model.INodePO;
import org.eclipse.jubula.client.core.model.IPersistentObject;
import org.eclipse.jubula.client.core.model.IProjectPO;
import org.eclipse.jubula.client.core.model.IRefTestSuitePO;
import org.eclipse.jubula.client.core.model.ITestSuitePO;
import org.eclipse.jubula.client.core.model.ITimestampPO;
import org.eclipse.jubula.client.core.persistence.EditSupport;
import org.eclipse.jubula.client.core.persistence.NodePM;
import org.eclipse.jubula.client.core.persistence.PMException;
import org.eclipse.jubula.client.ui.constants.CommandIDs;
import org.eclipse.jubula.client.ui.constants.ContextHelpIds;
import org.eclipse.jubula.client.ui.constants.IconConstants;
import org.eclipse.jubula.client.ui.rcp.Plugin;
import org.eclipse.jubula.client.ui.rcp.businessprocess.UINodeBP;
import org.eclipse.jubula.client.ui.rcp.constants.RCPCommandIDs;
import org.eclipse.jubula.client.ui.rcp.controllers.PMExceptionHandler;
import org.eclipse.jubula.client.ui.rcp.controllers.dnd.LocalSelectionTransfer;
import org.eclipse.jubula.client.ui.rcp.controllers.dnd.TJEditorDropTargetListener;
import org.eclipse.jubula.client.ui.rcp.controllers.dnd.TreeViewerContainerDragSourceListener;
import org.eclipse.jubula.client.ui.rcp.events.GuiEventDispatcher;
import org.eclipse.jubula.client.ui.rcp.i18n.Messages;
import org.eclipse.jubula.client.ui.rcp.provider.contentprovider.TestJobEditorContentProvider;
import org.eclipse.jubula.client.ui.utils.CommandHelper;
import org.eclipse.jubula.client.ui.utils.ErrorHandlingUtil;
import org.eclipse.jubula.tools.internal.exception.Assert;
import org.eclipse.jubula.tools.internal.exception.ProjectDeletedException;
import org.eclipse.jubula.tools.internal.messagehandling.MessageIDs;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IWorkbenchCommandConstants;
import org.eclipse.ui.menus.CommandContributionItem;

/**
 * The Test Job Editor
 * 
 * @author BREDEX GmbH
 * @created Mar 17, 2010
 */
public class TestJobEditor extends AbstractJBEditor {

    /**
     * {@inheritDoc}
     */
    public String getEditorPrefix() {
        return Messages.PluginTJ;
    }

    /**
     * {@inheritDoc}
     */
    public void createPartControlImpl(Composite parent) {
        createMainPart(parent);
        GridData gridData = new GridData(GridData.FILL_BOTH);
        getMainTreeViewer().getControl().setLayoutData(gridData);
        setControl(getMainTreeViewer().getControl());
        getMainTreeViewer().setContentProvider(new TestJobEditorContentProvider());
        addDragAndDropSupport();
        getEditorHelper().addListeners();
        setActionHandlers();
        addDoubleClickListener(CommandIDs.OPEN_SPECIFICATION_COMMAND_ID, getMainTreeViewer());
        setInitialInput();
        DataEventDispatcher ded = DataEventDispatcher.getInstance();
        ded.addPropertyChangedListener(this, true);
        GuiEventDispatcher.getInstance().addEditorDirtyStateListener(this, true);
    }

    @Override
    public void setInitialInput() {
        INodePO root = (INodePO) getEditorHelper().getEditSupport().getWorkVersion();
        try {
            getTreeViewer().getTree().getParent().setRedraw(false);
            getTreeViewer().setInput(new INodePO[] { root });
            getTreeViewer().expandAll();

        } finally {
            getTreeViewer().getTree().getParent().setRedraw(true);
        }
    }

    /**
     * adds Drag and Drop support for the trees.
     */
    protected void addDragAndDropSupport() {
        int ops = DND.DROP_MOVE;
        Transfer[] transfers = new Transfer[] { LocalSelectionTransfer.getInstance() };
        getMainTreeViewer().addDragSupport(ops, transfers,
                new TreeViewerContainerDragSourceListener(getTreeViewer()));
        getMainTreeViewer().addDropSupport(ops, transfers, new TJEditorDropTargetListener(this));
    }

    /**
     * {@inheritDoc}
     */
    protected void fillContextMenu(IMenuManager mgr) {
        CommandHelper.createContributionPushItem(mgr, IWorkbenchCommandConstants.EDIT_COPY);
        CommandHelper.createContributionPushItem(mgr, IWorkbenchCommandConstants.EDIT_PASTE);
        mgr.add(new Separator());
        mgr.add(new GroupMarker("editing")); //$NON-NLS-1$
        CommandHelper.createContributionPushItem(mgr, RCPCommandIDs.REVERT_CHANGES);
        mgr.add(new Separator());
        CommandHelper.createContributionPushItem(mgr, CommandIDs.DELETE_COMMAND_ID);
        mgr.add(CommandHelper.createContributionItem(RCPCommandIDs.FIND, null, Messages.FindContextMenu,
                CommandContributionItem.STYLE_PUSH));
        CommandHelper.createContributionPushItem(mgr, CommandIDs.OPEN_SPECIFICATION_COMMAND_ID);
        CommandHelper.createContributionPushItem(mgr, CommandIDs.SHOW_SPECIFICATION_COMMAND_ID);
        CommandHelper.createContributionPushItem(mgr, CommandIDs.EXPAND_TREE_ITEM_COMMAND_ID);
        mgr.add(new Separator());
        CommandHelper.createContributionPushItem(mgr, RCPCommandIDs.NEW_COMMENT);
        CommandHelper.createContributionPushItem(mgr, RCPCommandIDs.EDIT_COMMENT);
    }

    /**
     * {@inheritDoc}
     */
    protected void setHelp(Composite parent) {
        Plugin.getHelpSystem().setHelp(parent, ContextHelpIds.TEST_JOB_EDITOR);
    }

    /**
     * {@inheritDoc}
     */
    public void doSave(IProgressMonitor monitor) {
        monitor.beginTask(Messages.EditorsSaveEditors, IProgressMonitor.UNKNOWN);
        try {
            EditSupport editSupport = getEditorHelper().getEditSupport();
            final IPersistentObject perObj = editSupport.getWorkVersion();
            TimestampBP.refreshTimestamp((ITimestampPO) perObj);
            editSupport.saveWorkVersion();

            getEditorHelper().resetEditableState();
            getEditorHelper().setDirty(false);
        } catch (PMException e) {
            PMExceptionHandler.handlePMExceptionForMasterSession(e);
            try {
                reOpenEditor(((NodeEditorInput) getEditorInput()).getNode());
            } catch (PMException e1) {
                PMExceptionHandler.handlePMExceptionForEditor(e, this);
            }
        } catch (ProjectDeletedException e) {
            PMExceptionHandler.handleProjectDeletedException();
        } finally {
            monitor.done();
        }
    }

    /**
     * {@inheritDoc}
     */
    public Image getDisabledTitleImage() {
        return IconConstants.DISABLED_TJ_EDITOR_IMAGE;
    }

    /** {@inheritDoc} */
    public void handleDataChanged(DataChangedEvent... events) {
        for (DataChangedEvent e : events) {
            handleDataChanged(e.getPo(), e.getDataState());
        }
    }

    /**
     * {@inheritDoc}
     */
    public void handleDataChanged(IPersistentObject po, DataState dataState) {
        if (po instanceof INodePO) {
            TreeViewer tv = getTreeViewer();
            switch (dataState) {
            case Added:
                INodePO addedNode = (INodePO) po;
                INodePO editorNode = (INodePO) getEditorHelper().getEditSupport().getWorkVersion();
                if (editorNode.indexOf(addedNode) > -1) {
                    getTreeViewer().refresh();
                    getTreeViewer().expandAll();
                    UINodeBP.setFocusAndSelection(new StructuredSelection(addedNode), tv);
                }
                break;
            case Deleted:
                if (!(po instanceof IProjectPO)) {
                    getTreeViewer().refresh();
                    setFocus();
                }
                break;
            case Renamed:
                createPartName();
                break;
            case StructureModified:
                if (!handleStructureModified(po)) {
                    return;
                }
                break;
            case ReuseChanged:
                // nothing yet!
                break;
            default:
                Assert.notReached();
            }
            getEditorHelper().handleDataChanged(po, dataState);
        }
    }

    /**
     * Handles a PO that has been modified.
     * 
     * @param po
     *            The modified object.
     * @return <code>false</code> if an error occurs during handling. Otherwise,
     *         <code>true</code>.
     */
    private boolean handleStructureModified(IPersistentObject po) {
        if (po instanceof ITestSuitePO) {
            final ITestSuitePO testsuitePO = (ITestSuitePO) po;
            final INodePO workVersion = (INodePO) getEditorHelper().getEditSupport().getWorkVersion();
            final List<IRefTestSuitePO> refTestSuites = NodePM.getInternalRefTestSuites(testsuitePO.getGuid(),
                    testsuitePO.getParentProjectId());
            if (!refTestSuites.isEmpty() && containsWorkVersionReuses(workVersion, testsuitePO)) {
                if (Plugin.getActiveEditor() != this && isDirty()) {
                    ErrorHandlingUtil.createMessageDialog(MessageIDs.I_SAVE_AND_REOPEN_EDITOR,
                            new Object[] { getTitle(), testsuitePO.getName() }, null);
                    return false;
                }
                try {
                    reOpenEditor(getEditorHelper().getEditSupport().getOriginal());
                } catch (PMException e) {
                    ErrorHandlingUtil.createMessageDialog(MessageIDs.E_REFRESH_FAILED, null,
                            new String[] { Messages.ErrorMessageEDITOR_CLOSE });
                    getSite().getPage().closeEditor(this, false);
                }
                return false;
            }
        }

        return true;
    }

    /**
     * @param root
     *            node, where starts the validation
     * @param ts
     *            changed test suite
     * @return if editor contains an reusing testcase for given specTestCase
     */
    @SuppressWarnings("unchecked")
    private static boolean containsWorkVersionReuses(INodePO root, ITestSuitePO ts) {
        final Iterator it = root.getNodeListIterator();
        final List<INodePO> childList = IteratorUtils.toList(it);
        for (INodePO child : childList) {
            if (child instanceof IRefTestSuitePO) {
                final IRefTestSuitePO refTs = (IRefTestSuitePO) child;
                if (ts.getGuid().equals(refTs.getTestSuiteGuid())) {
                    return true;
                }
                if (containsWorkVersionReuses(refTs, ts)) {
                    return true;
                }
            }
        }
        return false;
    }
}