org.eclipse.emf.ecp.common.commands.DeleteModelElementCommand.java Source code

Introduction

Here is the source code for org.eclipse.emf.ecp.common.commands.DeleteModelElementCommand.java

Source

/*******************************************************************************
 * Copyright (c) 2008-2011 Chair for Applied Software Engineering,
 * Technische Universitaet Muenchen.
 * 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:
 ******************************************************************************/
package org.eclipse.emf.ecp.common.commands;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecp.common.model.ECPModelelementContext;
import org.eclipse.emf.ecp.common.model.workSpaceModel.util.AssociationClassHelper;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.PlatformUI;

/**
 * Command to delete a modelelement.
 * 
 * @author helming
 * @author shterev
 */
public final class DeleteModelElementCommand {

    private final Set<EObject> toBeDeleted;
    private final ECPModelelementContext context;

    /**
     * Default constructor.
     * 
     * @param element the model element to be deleted.
     * @param context the model element context
     */
    public DeleteModelElementCommand(EObject element, ECPModelelementContext context) {
        this(Collections.singleton(element), context);
    }

    /**
     * Default constructor.
     * 
     * @param elements the model elements to be deleted.
     * @param context the model element context
     */
    public DeleteModelElementCommand(Set<EObject> elements, ECPModelelementContext context) {
        this.toBeDeleted = elements;
        this.context = context;
    }

    /**
     * {@inheritDoc}
     */
    public void run() {
        // remove already contained model elements to prevent double deletes -> exception
        removeAnchestorDuplicates(toBeDeleted);

        // collect all association classes to be deleted
        Set<EObject> additionalMEs = new HashSet<EObject>();
        for (EObject eObject : toBeDeleted) {
            additionalMEs.addAll(AssociationClassHelper.getRelatedAssociationClassToDelete(eObject,
                    context.getMetaModelElementContext()));
        }
        toBeDeleted.addAll(additionalMEs);
        // now delete
        if (askConfirmation()) {
            ProgressMonitorDialog progressDialog = new ProgressMonitorDialog(
                    PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
            progressDialog.open();
            try {
                long start = System.currentTimeMillis();
                removeElementsWithoutRoot(toBeDeleted);

                if (toBeDeleted.size() > 0) {
                    new ECPCommandWithParameter<Set<EObject>>(toBeDeleted.iterator().next()) {

                        @Override
                        protected void doRun(Set<EObject> parameter) {
                            for (EObject eObject : toBeDeleted) {
                                EcoreUtil.delete(eObject, true);
                            }
                        }

                    }.run(toBeDeleted);
                }
                setStatusMessage(
                        "Element deletion lasted " + (System.currentTimeMillis() - start) / 1000.0 + "sec");
                // Command deleteCommand = DeleteCommand.create(context.getEditingDomain(), toBeDeleted);
                // context.getEditingDomain().getCommandStack().execute(deleteCommand);
            } finally {
                progressDialog.getProgressMonitor().done();
                progressDialog.close();
            }
        }
    }

    /**
     * Sets a message in the status line, if removes it, if message == null
     * 
     * @param message
     *            the message to be set
     */
    public static void setStatusMessage(String message) {
        IViewSite vSite = (IViewSite) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()
                .getActivePart().getSite();
        IActionBars actionBars = vSite.getActionBars();
        if (actionBars != null) {
            IStatusLineManager statusLineManager = actionBars.getStatusLineManager();
            if (statusLineManager != null) {
                statusLineManager.setMessage(message);
                System.out.println(message);
            }
        }
    }

    private void removeElementsWithoutRoot(Set<EObject> toBeDeleted) {
        HashSet<EObject> tmpRemove = new HashSet<EObject>();
        for (EObject obj : toBeDeleted) {
            if (obj.eContainer() == null) {
                obj.eResource().getContents().remove(obj);
                tmpRemove.add(obj);
            }
        }
        toBeDeleted.removeAll(tmpRemove);
    }

    private void removeAnchestorDuplicates(Set<EObject> toBeDeleted) {
        HashSet<EObject> toBeRemoved = new HashSet<EObject>();
        for (EObject obj : toBeDeleted) {
            if (parentIsContained(toBeDeleted, obj)) {
                toBeRemoved.add(obj);
            }
        }
        toBeDeleted.removeAll(toBeRemoved);
    }

    private boolean parentIsContained(Set<EObject> toBeDeleted, EObject obj) {
        EObject container = obj.eContainer();
        if (container == null) {
            return false;
        }
        if (toBeDeleted.contains(container)) {
            return true;
        }
        return parentIsContained(toBeDeleted, container);
    }

    private boolean askConfirmation() {
        String question = null;
        ComposedAdapterFactory adapterFactory = null;
        if (toBeDeleted.size() == 1) {
            adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
            AdapterFactoryLabelProvider adapterFactoryLabelProvider = new AdapterFactoryLabelProvider(
                    adapterFactory);
            String modelElementName = adapterFactoryLabelProvider.getText(toBeDeleted.iterator().next());
            question = "Do you really want to delete the model element " + modelElementName + "?";
        } else {
            question = "Do you really want to delete these " + toBeDeleted.size() + " model elements?";
        }
        MessageDialog dialog = new MessageDialog(null, "Confirmation", null, question, MessageDialog.QUESTION,
                new String[] { "Yes", "No" }, 0);

        boolean confirm = false;
        if (dialog.open() == MessageDialog.OK) {
            confirm = true;
        }

        if (adapterFactory != null) {
            adapterFactory.dispose();
        }

        return confirm;
    }
}