/*******************************************************************************
 * Copyright (c) 2005, 2006 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
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwtx.core.commands.operations.OperationHistoryEvent;

import dwtx.core.runtime.IStatus;
import dwtx.core.commands.operations.IOperationHistory;
import dwtx.core.commands.operations.IUndoableOperation;

import dwt.dwthelper.utils;

/**
 * <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 const 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 const 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 const 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 const 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 const 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 const 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 const 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 const 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 const 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 const 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 this(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 this(int code, IOperationHistory history,
            IUndoableOperation operation, IStatus status) {
        if (history is null) {
            throw new NullPointerException();
        }
        if (operation is 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;
    }

}