/*******************************************************************************
* Copyright (c) 2005, 2015 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.core.commands.operations;
import org.eclipse.core.runtime.IStatus;
/**
* <p>
* OperationHistoryEvent is used to communicate changes that occur in a
* DefaultOperationHistory, including the addition or removal of operations, and
* the execution, undo, and redo of operations.
* </p>
* <p>
* Operation history listeners must be prepared to receive notifications from a
* background thread. Any UI access occurring inside the implementation must be
* properly synchronized using the techniques specified by the client's widget
* library.
* </p>
*
*
* @since 3.1
*/
public final class OperationHistoryEvent {
/**
* ABOUT_TO_EXECUTE indicates that an operation is about to execute.
* Listeners should prepare for the execution as appropriate. Listeners will
* receive a DONE notification if the operation is successful, or an
* OPERATION_NOT_OK notification if the execution is cancelled or otherwise
* fails. This notification is only received for those operations executed
* by the operation history. Operations that are added to the history after
* execution do not trigger these notifications.
*
* If the operation successfully executes, clients will also receive a
* notification that it has been added to the history.
*
* (value is 1).
*/
public static final int ABOUT_TO_EXECUTE = 1;
/**
* ABOUT_TO_REDO indicates that an operation is about to be redone.
* Listeners should prepare for the redo as appropriate. Listeners will
* receive a REDONE notification if the operation is successful, or an
* OPERATION_NOT_OK notification if the redo is cancelled or otherwise
* fails.
*
* (value is 2).
*/
public static final int ABOUT_TO_REDO = 2;
/**
* ABOUT_TO_UNDO indicates that an operation is about to be undone.
* Listeners should prepare for the undo as appropriate. Listeners will
* receive an UNDONE notification if the operation is successful, or an
* OPERATION_NOT_OK notification if the undo is cancelled or otherwise
* fails.
*
* (value is 3).
*/
public static final int ABOUT_TO_UNDO = 3;
/**
* DONE indicates that an operation has been executed. Listeners can take
* appropriate action, such as revealing any relevant state in the UI. This
* notification is only received for those operations executed by the
* operation history. Operations that are added to the history after
* execution do not trigger this notification.
*
* Clients will also receive a notification that the operation has been
* added to the history.
*
* (value is 4).
*/
public static final int DONE = 4;
/**
* OPERATION_ADDED indicates that an operation was added to the history.
* Listeners can use this notification to add their undo context to a new
* operation as appropriate or otherwise record the operation.
*
* (value is 5).
*/
public static final int OPERATION_ADDED = 5;
/**
* OPERATION_CHANGED indicates that an operation has changed in some way
* since it was added to the operations history.
*
* (value is 6).
*/
public static final int OPERATION_CHANGED = 6;
/**
* OPERATION_NOT_OK indicates that an operation was attempted and not
* successful. Listeners typically use this when they have prepared for an
* execute, undo, or redo, and need to know that the operation did not
* successfully complete. For example, listeners that turn redraw off before
* an operation is undone would turn redraw on when the operation completes,
* or when this notification is received, since there will be no
* notification of the completion.
*
* (value is 7).
*/
public static final int OPERATION_NOT_OK = 7;
/**
* OPERATION_REMOVED indicates an operation was removed from the history.
* Listeners typically remove any record of the operation that they may have
* kept in their own state. The operation has been disposed by the time
* listeners receive this notification.
*
* (value is 8).
*/
public static final int OPERATION_REMOVED = 8;
/**
* REDONE indicates that an operation was redone. Listeners can take
* appropriate action, such as revealing any relevant state in the UI.
*
* (value is 9).
*/
public static final int REDONE = 9;
/**
* UNDONE indicates that an operation was undone. Listeners can take
* appropriate action, such as revealing any relevant state in the UI.
*
* (value is 10).
*/
public static final int UNDONE = 10;
private int code = 0;
private IOperationHistory history;
private IUndoableOperation operation;
/* @since 3.2 */
private IStatus status;
/**
* Construct an event for the specified operation history.
*
* @param code
* the event code to be used.
* @param history
* the history triggering the event.
* @param operation
* the operation involved in the event.
*/
public OperationHistoryEvent(int code, IOperationHistory history,
IUndoableOperation operation) {
this(code, history, operation, null);
}
/**
* Construct an event for the specified operation history.
*
* @param code
* the event code to be used.
* @param history
* the history triggering the event.
* @param operation
* the operation involved in the event.
* @param status
* the status associated with the event, or null if no status is
* available.
*
* @since 3.2
*/
public OperationHistoryEvent(int code, IOperationHistory history,
IUndoableOperation operation, IStatus status) {
if (history == null) {
throw new NullPointerException();
}
if (operation == null) {
throw new NullPointerException();
}
this.code = code;
this.history = history;
this.operation = operation;
this.status = status;
}
/**
* Return the type of event that is occurring.
*
* @return the type code indicating the type of event.
*/
public int getEventType() {
return code;
}
/**
* Return the operation history that triggered this event.
*
* @return the operation history
*/
public IOperationHistory getHistory() {
return history;
}
/**
* Return the operation associated with this event.
*
* @return the operation
*/
public IUndoableOperation getOperation() {
return operation;
}
/**
* Return the status associated with this event.
*
* @return the status associated with this event. The status may be null.
*
* @since 3.2
*/
public IStatus getStatus() {
return status;
}
}