Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 


Eclipse Platform
Release 3.5

org.eclipse.ui.ide.undo
Class AbstractWorkspaceOperation

java.lang.Object
  extended by 

org.eclipse.core.commands.operations.AbstractOperation
      extended by 
org.eclipse.ui.ide.undo.AbstractWorkspaceOperation
All Implemented Interfaces:
IAdvancedUndoableOperation, IAdvancedUndoableOperation2, IUndoableOperation
Direct Known Subclasses:
CopyProjectOperation, CopyResourcesOperation, CreateFileOperation, CreateFolderOperation, CreateMarkersOperation, CreateProjectOperation, DeleteMarkersOperation, DeleteResourcesOperation, MoveProjectOperation, MoveResourcesOperation, UpdateMarkersOperation

public abstract class AbstractWorkspaceOperation
extends AbstractOperation
implements IAdvancedUndoableOperation, IAdvancedUndoableOperation2

An AbstractWorkspaceOperation represents an undoable operation that affects the workspace. It handles common workspace operation activities such as tracking which resources are affected by an operation, prompting the user when there are possible side effects of operations, building execution exceptions from core exceptions, etc. Clients may call the public API from a background thread. This class is not intended to be subclassed by clients.

Since:
3.3

Field Summary
protected static int EXECUTE
           
protected  boolean quietCompute
           
protected static int REDO
           
protected   IResource[] resources
           
protected static int UNDO
           
 
Method Summary
 void aboutToNotify ( OperationHistoryEvent event)
           An operation history notification about this operation is about to be sent to operation history listeners.
protected  void appendDescriptiveText ( StringBuffer text)
          Append any descriptive text to the specified string buffer to be shown in the receiver's toString() text.
 boolean canExecute ()
           Returns whether the operation can be executed in its current state.
 boolean canRedo ()
           Returns whether the operation can be redone in its current state.
 boolean canUndo ()
           Returns whether the operation can be undone in its current state.
  IStatus computeExecutionStatus ( IProgressMonitor monitor)
          Return a status indicating the projected outcome of executing the receiver.
  IStatus computeRedoableStatus ( IProgressMonitor monitor)
          Return a status indicating the projected outcome of redoing the receiver.
  IStatus computeUndoableStatus ( IProgressMonitor monitor)
          Return a status indicating the projected outcome of undoing the receiver.
protected abstract  void doExecute ( IProgressMonitor monitor, IAdaptable uiInfo)
          Perform the specific work involved in executing this operation.
protected abstract  void doUndo ( IProgressMonitor monitor, IAdaptable uiInfo)
          Perform the specific work involved in undoing this operation.
  IStatus execute ( IProgressMonitor monitor, IAdaptable uiInfo)
          Execute the specified operation.
  Object[] getAffectedObjects ()
           Return an array of objects that are affected by executing, undoing, or redoing this operation.
protected   IStatus getErrorStatus ( String message)
          Return an error status describing an invalid operation using the provided message.
protected   ISchedulingRule getExecuteSchedulingRule ()
          Return a scheduling rule appropriate for executing this operation.
protected   ISchedulingRule getRedoSchedulingRule ()
          Return a scheduling rule appropriate for redoing this operation.
protected   Shell getShell ( IAdaptable uiInfo)
          Return the shell described by the specified adaptable, or the active shell if no shell has been specified in the adaptable.
protected   ISchedulingRule getUndoSchedulingRule ()
          Return a scheduling rule appropriate for undoing this operation.
protected   IStatus getWarningStatus ( String message, int code)
          Return a warning status describing the warning state of an operation using the provided message and code.
protected   IWorkspace getWorkspace ()
          Return the workspace manipulated by this operation.
protected   IResourceRuleFactory getWorkspaceRuleFactory ()
          Return the workspace rule factory associated with this operation.
protected  boolean isValid ()
          Return whether the proposed operation is valid.
protected  void markInvalid ()
          Mark this operation invalid due to some external change.
  IStatus redo ( IProgressMonitor monitor, IAdaptable uiInfo)
          Redo the specified operation.
protected  boolean resourcesExist ()
          Return whether the resources known by this operation currently exist.
protected  boolean resourcesIncludesProjects ()
          Return whether the resources known by this operation contain any projects.
 boolean runInBackground ()
          Return a boolean that instructs whether the operation should be executed, undone, or redone in a background thread.
 void setModelProviderIds ( String[] ids)
          Set the ids of any model providers for the resources involved.
 void setQuietCompute (boolean quiet)
          Set a boolean that instructs whether the computation of the receiver's execution, undo, or redo status should quietly compute status without consulting or prompting the user.
protected  void setTargetResources ( IResource[] resources)
          Set the resources which are affected by this operation
  String toString ()
          The string representation of this operation.
  IStatus undo ( IProgressMonitor monitor, IAdaptable uiInfo)
          Undo the specified operation.
protected  boolean updateResourceChangeDescriptionFactory ( IResourceChangeDescriptionFactory factory, int operation)
          Update the provided resource change description factory so it can generate a resource delta describing the result of an undo or redo.
 
Methods inherited from class org.eclipse.core.commands.operations. AbstractOperation
addContext, dispose, getContexts, getLabel, hasContext, removeContext, setLabel
 
Methods inherited from class java.lang. Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

EXECUTE

protected static int EXECUTE

UNDO

protected static int UNDO

REDO

protected static int REDO

resources

protected 
IResource[] resources

quietCompute

protected boolean quietCompute
Method Detail

setModelProviderIds

public void setModelProviderIds(
String[] ids)
Set the ids of any model providers for the resources involved.

Parameters:
ids - the array of String model provider ids that provide models associated with the resources involved in this operation

setTargetResources

protected void setTargetResources(
IResource[] resources)
Set the resources which are affected by this operation

Parameters:
resources - an array of resources

getWorkspace

protected 
IWorkspace getWorkspace()
Return the workspace manipulated by this operation.

Returns:
the IWorkspace used by this operation.

getWorkspaceRuleFactory

protected 
IResourceRuleFactory getWorkspaceRuleFactory()
Return the workspace rule factory associated with this operation.

Returns:
the IResourceRuleFactory associated with this operation.

markInvalid

protected void markInvalid()
Mark this operation invalid due to some external change. May be used by subclasses.


canExecute

public boolean canExecute()
Description copied from interface: IUndoableOperation

Returns whether the operation can be executed in its current state.

Note: The computation for this method must be fast, as it is called frequently. If necessary, this method can be optimistic in its computation (returning true) and later perform more time-consuming computations during the actual execution of the operation, returning the appropriate status if the operation cannot actually execute at that time.

Specified by:
canExecute in interface IUndoableOperation
Overrides:
canExecute in class AbstractOperation
Returns:
true if the operation can be executed; false otherwise.

canUndo

public boolean canUndo()
Description copied from interface: IUndoableOperation

Returns whether the operation can be undone in its current state.

Note: The computation for this method must be fast, as it is called frequently. If necessary, this method can be optimistic in its computation (returning true) and later perform more time-consuming computations during the actual undo of the operation, returning the appropriate status if the operation cannot actually be undone at that time.

Specified by:
canUndo in interface IUndoableOperation
Overrides:
canUndo in class AbstractOperation
Returns:
true if the operation can be undone; false otherwise.

canRedo

public boolean canRedo()
Description copied from interface: IUndoableOperation

Returns whether the operation can be redone in its current state.

Note: The computation for this method must be fast, as it is called frequently. If necessary, this method can be optimistic in its computation (returning true) and later perform more time-consuming computations during the actual redo of the operation, returning the appropriate status if the operation cannot actually be redone at that time.

Specified by:
canRedo in interface IUndoableOperation
Overrides:
canRedo in class AbstractOperation
Returns:
true if the operation can be redone; false otherwise.

execute

public 
IStatus execute(
IProgressMonitor monitor,
                       
IAdaptable uiInfo)
                throws 
ExecutionException
Execute the specified operation. This implementation executes the operation in a workspace runnable and catches any CoreExceptions resulting from the operation. Unhandled CoreExceptions are propagated as ExecutionExceptions.

Specified by:
execute in interface IUndoableOperation
Specified by:
execute in class AbstractOperation
Parameters:
monitor - the progress monitor to use for the operation
uiInfo - the IAdaptable (or null) provided by the caller in order to supply UI information for prompting the user if necessary. When this parameter is not null, it contains an adapter for the org.eclipse.swt.widgets.Shell.class
Returns:
the IStatus of the execution. The status severity should be set to OK if the operation was successful, and ERROR if it was not. Any other status is assumed to represent an incompletion of the execution.
Throws:
ExecutionException - if an exception occurred during execution.
See Also:
IUndoableOperation.execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

redo

public 
IStatus redo(
IProgressMonitor monitor,
                    
IAdaptable uiInfo)
             throws 
ExecutionException
Redo the specified operation. This implementation redoes the operation in a workspace runnable and catches any CoreExceptions resulting from the operation. Unhandled CoreExceptions are propagated as ExecutionExceptions.

Specified by:
redo in interface IUndoableOperation
Specified by:
redo in class AbstractOperation
Parameters:
monitor - the progress monitor to use for the operation
uiInfo - the IAdaptable (or null) provided by the caller in order to supply UI information for prompting the user if necessary. When this parameter is not null, it contains an adapter for the org.eclipse.swt.widgets.Shell.class
Returns:
the IStatus of the redo. The status severity should be set to OK if the operation was successful, and ERROR if it was not. Any other status is assumed to represent an incompletion of the redo.
Throws:
ExecutionException - if an exception occurred during execution.
See Also:
IUndoableOperation.redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

undo

public 
IStatus undo(
IProgressMonitor monitor,
                    
IAdaptable uiInfo)
             throws 
ExecutionException
Undo the specified operation. This implementation undoes the operation in a workspace runnable and catches any CoreExceptions resulting from the operation. Unhandled CoreExceptions are propagated as ExecutionExceptions.

Specified by:
undo in interface IUndoableOperation
Specified by:
undo in class AbstractOperation
Parameters:
monitor - the progress monitor to use for the operation
uiInfo - the IAdaptable (or null) provided by the caller in order to supply UI information for prompting the user if necessary. When this parameter is not null, it contains an adapter for the org.eclipse.swt.widgets.Shell.class
Returns:
the IStatus of the undo. The status severity should be set to OK if the operation was successful, and ERROR if it was not. Any other status is assumed to represent an incompletion of the undo. *
Throws:
ExecutionException - if an exception occurred during execution.
See Also:
IUndoableOperation.undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

doUndo

protected abstract void doUndo(
IProgressMonitor monitor,
                               
IAdaptable uiInfo)
                        throws 
CoreException
Perform the specific work involved in undoing this operation.

Parameters:
monitor - the progress monitor to use for the operation
uiInfo - the IAdaptable (or null) provided by the caller in order to supply UI information for prompting the user if necessary. When this parameter is not null, it contains an adapter for the org.eclipse.swt.widgets.Shell.class
Throws:
CoreException - propagates any CoreExceptions thrown from the resources API

doExecute

protected abstract void doExecute(
IProgressMonitor monitor,
                                  
IAdaptable uiInfo)
                           throws 
CoreException
Perform the specific work involved in executing this operation.

Parameters:
monitor - the progress monitor to use for the operation
uiInfo - the IAdaptable (or null) provided by the caller in order to supply UI information for prompting the user if necessary. When this parameter is not null, it contains an adapter for the org.eclipse.swt.widgets.Shell.class
Throws:
CoreException - propagates any CoreExceptions thrown from the resources API

isValid

protected boolean isValid()
Return whether the proposed operation is valid. The default implementation simply checks to see if the flag has been marked as invalid, relying on subclasses to mark the flag invalid when appropriate.

Returns:
the validity flag

aboutToNotify

public void aboutToNotify(
OperationHistoryEvent event)
Description copied from interface: IAdvancedUndoableOperation

An operation history notification about this operation is about to be sent to operation history listeners. Any preparation needed before listeners are notified about this operation should be performed here.

This method has been added to support legacy undo frameworks that are adapting to IUndoableOperation. Operations that previously relied on notification from their containing history or stack before any listeners are notified about changes to the operation should implement this interface.

Specified by:
aboutToNotify in interface IAdvancedUndoableOperation
Parameters:
event - the event that is about to be sent with the pending notification

getAffectedObjects

public 
Object[] getAffectedObjects()
Description copied from interface: IAdvancedUndoableOperation

Return an array of objects that are affected by executing, undoing, or redoing this operation. If it cannot be determined which objects are affected, return null.

Specified by:
getAffectedObjects in interface IAdvancedUndoableOperation
Returns:
the array of Objects modified by this operation, or null if the affected objects cannot be determined.

computeExecutionStatus

public 
IStatus computeExecutionStatus(
IProgressMonitor monitor)
Return a status indicating the projected outcome of executing the receiver. This method is not called by the operation history, but instead is used by clients (such as implementers of IOperationApprover2) who wish to perform advanced validation of an operation before attempting to execute it. If an ERROR status is returned, the operation will not proceed and the user notified if deemed necessary by the caller. The validity flag on the operation should be marked as invalid. If an OK status is returned, the operation will proceed. The caller must interpret any other returned status severity, and may choose to prompt the user as to how to proceed. If there are multiple conditions that result in an ambiguous status severity, it is best for the implementor of this method to consult the user as to how to proceed for each one, and return an OK or ERROR status that accurately reflects the user's wishes, or to return a multi-status that accurately describes all of the issues at hand, so that the caller may potentially consult the user. (Note that the user should not be consulted at all if a client has called setQuietCompute(boolean) with a value of true.) This implementation computes the validity of execution by computing the resource delta that would be generated on execution, and checking whether any registered model providers are affected by the operation.

Specified by:
computeExecutionStatus in interface IAdvancedUndoableOperation2
Parameters:
monitor - the progress monitor to be used for computing the status
Returns:
the status indicating the projected outcome of executing the receiver
See Also:
IAdvancedUndoableOperation.computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor), setQuietCompute(boolean)

computeUndoableStatus

public 
IStatus computeUndoableStatus(
IProgressMonitor monitor)
Return a status indicating the projected outcome of undoing the receiver. This method is not called by the operation history, but instead is used by clients (such as implementers of IOperationApprover2) who wish to perform advanced validation of an operation before attempting to undo it. If an ERROR status is returned, the undo will not proceed and the user notified if deemed necessary by the caller. The validity flag on the operation should be marked as invalid. If an OK status is returned, the undo will proceed. The caller must interpret any other returned status severity, and may choose to prompt the user as to how to proceed. If there are multiple conditions that result in an ambiguous status severity, it is best for the implementor of this method to consult the user as to how to proceed for each one, and return an OK or ERROR status that accurately reflects the user's wishes, or to return a multi-status that accurately describes all of the issues at hand, so that the caller may potentially consult the user. (Note that the user should not be consulted at all if a client has called setQuietCompute(boolean) with a value of true.) This implementation computes the validity of undo by computing the resource delta that would be generated on undo, and checking whether any registered model providers are affected by the operation.

Specified by:
computeUndoableStatus in interface IAdvancedUndoableOperation
Parameters:
monitor - the progress monitor to be used for computing the status
Returns:
the status indicating the projected outcome of undoing the receiver
See Also:
IAdvancedUndoableOperation.computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor), setQuietCompute(boolean)

computeRedoableStatus

public 
IStatus computeRedoableStatus(
IProgressMonitor monitor)
Return a status indicating the projected outcome of redoing the receiver. This method is not called by the operation history, but instead is used by clients (such as implementers of IOperationApprover2) who wish to perform advanced validation of an operation before attempting to redo it. If an ERROR status is returned, the redo will not proceed and the user notified if deemed necessary by the caller. The validity flag on the operation should be marked as invalid. If an OK status is returned, the redo will proceed. The caller must interpret any other returned status severity, and may choose to prompt the user as to how to proceed. If there are multiple conditions that result in an ambiguous status severity, it is best for the implementor of this method to consult the user as to how to proceed for each one, and return an OK or ERROR status that accurately reflects the user's wishes, or to return a multi-status that accurately describes all of the issues at hand, so that the caller may potentially consult the user. (Note that the user should not be consulted at all if a client has called setQuietCompute(boolean) with a value of true.) This implementation computes the validity of redo by computing the resource delta that would be generated on redo, and checking whether any registered model providers are affected by the operation.

Specified by:
computeRedoableStatus in interface IAdvancedUndoableOperation
Parameters:
monitor - the progress monitor to be used for computing the status
Returns:
the status indicating the projected outcome of redoing the receiver
See Also:
IAdvancedUndoableOperation.computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor), setQuietCompute(boolean)

updateResourceChangeDescriptionFactory

protected boolean updateResourceChangeDescriptionFactory(
IResourceChangeDescriptionFactory factory,
                                                         int operation)
Update the provided resource change description factory so it can generate a resource delta describing the result of an undo or redo. Return a boolean indicating whether any update was done. The default implementation does not update the factory. Subclasses are expected to override this method to more specifically describe their modifications to the workspace.

Parameters:
factory - the factory to update
operation - an integer indicating whether the change is part of an execute, undo, or redo
Returns:
a boolean indicating whether the factory was updated.

getErrorStatus

protected 
IStatus getErrorStatus(
String message)
Return an error status describing an invalid operation using the provided message.

Parameters:
message - the message to be used in the status, or null if a generic message should be used
Returns:
the error status

getWarningStatus

protected 
IStatus getWarningStatus(
String message,
                                   int code)
Return a warning status describing the warning state of an operation using the provided message and code.

Parameters:
message - the message to be used in the status, or null if a generic message should be used
code - the integer code to be assigned to the status
Returns:
the warning status

resourcesExist

protected boolean resourcesExist()
Return whether the resources known by this operation currently exist.

Returns:
true if there are existing resources and false if there are no known resources or any one of them does not exist

resourcesIncludesProjects

protected boolean resourcesIncludesProjects()
Return whether the resources known by this operation contain any projects.

Returns:
true if there is one or more projects known by this operation and false if there are no projects.

getExecuteSchedulingRule

protected 
ISchedulingRule getExecuteSchedulingRule()
Return a scheduling rule appropriate for executing this operation. The default implementation is to return a rule that locks out the entire workspace. Subclasses are encouraged to provide more specific rules that affect only their resources.

Returns:
the scheduling rule to use when executing this operation, or null if there are no scheduling restrictions for this operation.
See Also:
IWorkspace.run(IWorkspaceRunnable, ISchedulingRule, int, IProgressMonitor)

getUndoSchedulingRule

protected 
ISchedulingRule getUndoSchedulingRule()
Return a scheduling rule appropriate for undoing this operation. The default implementation is to return a rule that locks out the entire workspace. Subclasses are encouraged to provide more specific rules that affect only their resources.

Returns:
the scheduling rule to use when undoing this operation, or null if there are no scheduling restrictions for this operation.
See Also:
IWorkspace.run(IWorkspaceRunnable, ISchedulingRule, int, IProgressMonitor)

getRedoSchedulingRule

protected 
ISchedulingRule getRedoSchedulingRule()
Return a scheduling rule appropriate for redoing this operation. The default implementation considers the redo scheduling rule the same as the original execution scheduling rule.

Returns:
the scheduling rule to use when redoing this operation, or null if there are no scheduling restrictions for this operation.
See Also:
IWorkspace.run(IWorkspaceRunnable, ISchedulingRule, int, IProgressMonitor)

setQuietCompute

public void setQuietCompute(boolean quiet)
Description copied from interface: IAdvancedUndoableOperation2
Set a boolean that instructs whether the computation of the receiver's execution, undo, or redo status should quietly compute status without consulting or prompting the user. The default value is false. This flag should only be set to true while the execution, undo, or redo status computations are being performed in the background, and should be restored to false when complete.

If the status computation methods typically need to consult the user in order to determine the severity of a particular situation, the least severe status that could be chosen by the user should be returned when this flag is true. This can help to prevent overzealous disposal of the operation history when an operation is in an ambiguous state. Typically, the status computation methods are invoked with this flag set to false just before the actual execution, undo, or redo occurs, so the user can be consulted for the final outcome.

Specified by:
setQuietCompute in interface IAdvancedUndoableOperation2
Parameters:
quiet - true if it is inappropriate to consult or otherwise prompt the user while computing status, and false if the user may be prompted.
See Also:
IAdvancedUndoableOperation2.computeExecutionStatus(IProgressMonitor), IAdvancedUndoableOperation.computeUndoableStatus(IProgressMonitor), IAdvancedUndoableOperation.computeRedoableStatus(IProgressMonitor)

toString

public 
String toString()
Description copied from class: AbstractOperation
The string representation of this operation. Used for debugging purposes only. This string should not be shown to an end user.

Overrides:
toString in class AbstractOperation
Returns:
The string representation.

appendDescriptiveText

protected void appendDescriptiveText(
StringBuffer text)
Append any descriptive text to the specified string buffer to be shown in the receiver's toString() text.

Note that this method is not intend to be subclassed by clients.

Parameters:
text - the StringBuffer on which to append the text

getShell

protected 
Shell getShell(
IAdaptable uiInfo)
Return the shell described by the specified adaptable, or the active shell if no shell has been specified in the adaptable.

Parameters:
uiInfo - the IAdaptable (or null) provided by the caller in order to supply UI information for prompting the user if necessary. When this parameter is not null, it contains an adapter for the org.eclipse.swt.widgets.Shell.class
Returns:
the shell specified in the adaptable, or the active shell if no shell has been specified

runInBackground

public boolean runInBackground()
Description copied from interface: IAdvancedUndoableOperation2
Return a boolean that instructs whether the operation should be executed, undone, or redone in a background thread.

Specified by:
runInBackground in interface IAdvancedUndoableOperation2
Returns:
true if the operation should be run in the background, false if it should not.

Eclipse Platform
Release 3.5

Guidelines for using Eclipse APIs.

Copyright (c) Eclipse contributors and others 2000, 2008. All rights reserved.


 
 
  Published under the terms of the Eclipse Public License Version 1.0 ("EPL") Design by Interspire