UndoableModelPropertySheetEntry.java

/******************************************************************************
 * Copyright (c) 2003, 2010 IBM Corporation and others.
 * 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:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.runtime.emf.ui.properties.sections;

import java.text.MessageFormat;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IOperationHistory;
import org.eclipse.core.commands.operations.TriggeredOperations;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.gmf.runtime.common.core.command.CompositeCommand;
import org.eclipse.gmf.runtime.common.core.command.ICommand;
import org.eclipse.gmf.runtime.common.core.command.ICompositeCommand;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.common.core.util.Trace;
import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand;
import org.eclipse.gmf.runtime.emf.ui.properties.commands.RestoreDefaultPropertyValueCommand;
import org.eclipse.gmf.runtime.emf.ui.properties.commands.SetModelPropertyValueCommand;
import org.eclipse.gmf.runtime.emf.ui.properties.internal.EMFPropertiesDebugOptions;
import org.eclipse.gmf.runtime.emf.ui.properties.internal.EMFPropertiesPlugin;
import org.eclipse.gmf.runtime.emf.ui.properties.internal.EMFPropertiesStatusCodes;
import org.eclipse.gmf.runtime.emf.ui.properties.internal.l10n.EMFUIPropertiesMessages;
import org.eclipse.ui.views.properties.IPropertySource;

/**
 * An property sheet entry for elements in the model. The changes to the model
 * element property are done through a model command executed by the
 * <code>CommandManager</code> so that the changes can be undone by undo
 * interval ID.
 * 
 * @author ldamus
 * @author nbalaba
 */
public class UndoableModelPropertySheetEntry extends PropertySheetEntry {

    /**
     * The operation history used by this entry to execute property change
     * commands. <code>Null</code> if I am not the root entry. Only the root
     * entry keeps track of the history on behalf of all of the child
     * entries.
     */
    private final IOperationHistory operationHistory;
    
    /**
     * My editing domain.
     */
    private TransactionalEditingDomain editingDomain;
    
    /**
     * Intializes me with an operation history through
     * which property change commands will be executed, undone and redone.
     * 
     * @param operationHistory
     *            my operation history
     */
    public UndoableModelPropertySheetEntry(IOperationHistory operationHistory) {
        this.operationHistory = operationHistory;
    }
    
    /**
     * Sets my editing domain.
     * 
     * @param editingDomain
     *            my editing domain
     */
    public void setEditingDomain(TransactionalEditingDomain editingDomain) {
        this.editingDomain = editingDomain;
    }
    
    /**
     * Gets my editing domain. The root entry stores the editing domain.
     * 
     * @return my editing domain
     */
    public TransactionalEditingDomain getEditingDomain() {

        UndoableModelPropertySheetEntry parentEntry = getParentEntry();

        if (parentEntry == null || editingDomain != null) {
            return editingDomain;
        }

        return parentEntry.getEditingDomain();
    }

    /*
     * (non-Javadoc) Method declared on IPropertySheetEntry.
     */
    public void applyEditorValue() {
    	if (editor == null) {
    	 	return;
    	}
        
    	 if (!editor.isValueValid()) {
            setErrorText(editor.getErrorMessage());
            return;
        } else 
            setErrorText(null);


        // See if the value changed and if so update
        
        Object newValue = editor.getValue();
        boolean changed = false;
        if (values.length > 1) {
            changed = true;
        } else if (editValue == null) {
            if (newValue != null)
                changed = true;
        } else if (!editValue.equals(newValue))
            changed = true;

        // Set the editor value
        if (changed)
            setValue(newValue);

    }

    /*
     * (non-Javadoc) Method declared on IUndoablePropertySheetEntry.
     */
    public void resetPropertyValue() {

        // The root entry does not have a default value
        if (parent == null) {
            return;
        }

        //Use our parent's values to reset our values.
        String propertyName = getDescriptor().getDisplayName();
        Object propertyId = getDescriptor().getId();
        CompositeCommand cc = new CompositeCommand(propertyName);
        RestoreDefaultPropertyValueCommand restoreCommand;
        boolean executeCommand = false;
        Object[] parentValues = getParentEntry().getValues();

        for (int i = 0; i < parentValues.length; i++) {

            IPropertySource source = getPropertySource(parentValues[i]);

            if (source.isPropertySet(propertyId)) {
                restoreCommand = new RestoreDefaultPropertyValueCommand(getEditingDomain(), 
                        propertyName, parentValues[i], source, propertyId);
                cc.compose(restoreCommand);
                executeCommand = true;
            }
        }

        if (executeCommand) {
            /* status is ok, can edit the storage units */
            try {
                TriggeredOperations triggerOperation = 
                    new TriggeredOperations(cc, getOperationHistory());
                getOperationHistory().execute(triggerOperation, new NullProgressMonitor(), null);
                
            } catch (ExecutionException e) {
                Trace.catching(EMFPropertiesPlugin.getDefault(),
                    EMFPropertiesDebugOptions.EXCEPTIONS_CATCHING,
                    UndoableModelPropertySheetEntry.class,
                    "resetPropertyValue", e); //$NON-NLS-1$
                Log.error(EMFPropertiesPlugin.getDefault(),
                    EMFPropertiesStatusCodes.COMMAND_FAILURE, e
                        .getLocalizedMessage(), e);
            }
            refreshValues();
        }
    }

    /**
     * Set the value for this entry.
     * <p>
     * We set the given value as the value for all our value objects. We then
     * call our parent to update the property we represent with the given value.
     * We then trigger a model refresh.
     * <p>
     * 
     * @param newValue
     *            the new value
     */
    protected void setValue(Object newValue) {

        // Set the value
        for (int i = 0; i < values.length; i++)
            values[i] = newValue;

        // Inform our parent
        IStatus status = getParentEntry().executeValueChangedCommand(
                this,
                getCompositeCommand(MessageFormat.format(
                		EMFUIPropertiesMessages.UndoablePropertySheetEntry_commandName,
                        new String[] { getDescriptor().getDisplayName() })));
        
        // Remember the new value so that we don't apply this same value more
        // than once.
        if (status.isOK())
        	editValue = newValue;
    }

    /**
     * The value of the given child entry has changed. Therefore we must set
     * this change into our value objects.
     * <p>
     * We must inform our parent so that it can update its value objects
     * </p>
     * <p>
     * Subclasses may override to set the property value in some custom way.
     * </p>
     * 
     * @param child
     *            the child entry that changed its value
     * @param command
     *            the command into which to compose my property change command
     * @see executeValueChanged
     */
    @Deprecated
    protected void valueChanged(UndoableModelPropertySheetEntry child,
            ICommand command) {
    	executeValueChangedCommand(child, command);
    }
    
    
    /**
     * The value of the given child entry has changed. Therefore we must set
     * this change into our value objects.
     * <p>
     * We must inform our parent so that it can update its value objects
     * </p>
     * <p>
     * Subclasses may override to set the property value in some custom way.
     * </p>
     * 
     * @param child
     *            the child entry that changed its value
     * @param command
     *            the command into which to compose my property change command
     * @return the the IStatus indicating whether the execution succeeded.
     * @since 1.4
     */
    protected IStatus executeValueChangedCommand(UndoableModelPropertySheetEntry child,
            ICommand command) {

        String propertyName = child.getDescriptor().getDisplayName();

        Object propertyId = child.getDescriptor().getId();

        for (int i = 0; i < values.length; i++)
            command.compose(getPropertyCommand(propertyName, values[i],
                    propertyId, child.getEditValue(i)));

        // inform our parent
        if (getParentEntry() != null) {
            return getParentEntry().executeValueChangedCommand(this, command);
        } else {
            //I am the root entry
            try {
                TriggeredOperations triggerOperation = 
                    new TriggeredOperations(command, getOperationHistory());
                return getOperationHistory().execute(triggerOperation, new NullProgressMonitor(), null);
          
            } catch (ExecutionException e) {
                Trace.catching(EMFPropertiesPlugin.getDefault(),
                    EMFPropertiesDebugOptions.EXCEPTIONS_CATCHING,
                    UndoableModelPropertySheetEntry.class,
                    "valueChanged", e); //$NON-NLS-1$
                Log.error(EMFPropertiesPlugin.getDefault(),
                    EMFPropertiesStatusCodes.COMMAND_FAILURE, e
                        .getLocalizedMessage(), e);
            }
            return Status.CANCEL_STATUS;
        }
    }
    
    
    /**
     * Extracts the editing domain from the <code>objects</code> if I am the
     * root entry.
     */
    public void setValues(Object[] objects) {
        super.setValues(objects);

        if (getParentEntry() == null) {
            // I'm the root
            for (int i = 0; i < objects.length; i++) {
                EObject eObject = null;

                if (objects[i] instanceof EObject) {
                    eObject = (EObject) objects[i];

                } else if (objects[i] instanceof IAdaptable) {
                    eObject = (EObject) ((IAdaptable) objects[i])
                        .getAdapter(EObject.class);
                }

                if (eObject != null) {
                    setEditingDomain(TransactionUtil.getEditingDomain(eObject));
                }
            }
        }
    }
    
    /**
     * Gets my operation history.
     * 
     * @return my operation history
     */
    protected final IOperationHistory getOperationHistory() {
        return operationHistory;
    }

    /**
     * Returns the parent. This can be another <code>PropertySheetEntry</code>
     * or <code>null</code>.
     */
    protected UndoableModelPropertySheetEntry getParentEntry() {
        return (UndoableModelPropertySheetEntry) parent;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.gmf.runtime.common.ui.internal.views.properties.UndoablePropertySheetEntry#getPropertyCommand(java.lang.String,
     *      org.eclipse.ui.views.properties.IPropertySource, java.lang.Object,
     *      java.lang.Object)
     */
    protected ICommand getPropertyCommand(String propertyName, Object object,
            Object propertyId, Object value) {

        return new SetModelPropertyValueCommand(getEditingDomain(), propertyName, object,
                getPropertySource(object), propertyId, value);
    }

    protected ICompositeCommand getCompositeCommand(String propertyName) {
        return new CompositeTransactionalCommand(getEditingDomain(), propertyName);
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.gmf.runtime.common.ui.internal.views.properties.UndoablePropertySheetEntry#createChildEntries(int)
     */
    protected PropertySheetEntry[] createChildEntries(int size) {
        return new UndoableModelPropertySheetEntry[size];
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.gmf.runtime.common.ui.internal.views.properties.UndoablePropertySheetEntry#createChildEntry()
     */
    protected PropertySheetEntry createChildEntry() {
        return new UndoableModelPropertySheetEntry(getOperationHistory());

    }

}