Java OperationHistoryEvent.UNDONE属性代码示例

private static String decodeEventType(int eventType) {
	String typeString = null;
	switch(eventType) {
		case OperationHistoryEvent.ABOUT_TO_EXECUTE:typeString="ABOUT_TO_EXECUTE";break;
		case OperationHistoryEvent.ABOUT_TO_REDO:typeString="ABOUT_TO_REDO";break;
		case OperationHistoryEvent.ABOUT_TO_UNDO:typeString="ABOUT_TO_UNDO";break;
		case OperationHistoryEvent.DONE:typeString="DONE";break;
		case OperationHistoryEvent.OPERATION_ADDED:typeString="OPERATION_ADDED";break;
		case OperationHistoryEvent.OPERATION_CHANGED:typeString="OPERATION_CHANGED";break;
		case OperationHistoryEvent.OPERATION_NOT_OK:typeString="OPERATION_NOT_OK";break;
		case OperationHistoryEvent.OPERATION_REMOVED:typeString="OPERATION_REMOVED";break;
		case OperationHistoryEvent.REDONE:typeString="REDONE";break;
		case OperationHistoryEvent.UNDONE:typeString="UNDONE";break;
	}
	return typeString;
}
 

@Override
public void historyNotification(OperationHistoryEvent event) {
	switch (event.getEventType()) {
	case OperationHistoryEvent.ABOUT_TO_EXECUTE:
	case OperationHistoryEvent.ABOUT_TO_REDO:
	case OperationHistoryEvent.ABOUT_TO_UNDO:
		if (WidgetUtils.inDisplayThread()) {
			Animation.markBegin();
		}
		break;
	case OperationHistoryEvent.DONE:
	case OperationHistoryEvent.REDONE:
	case OperationHistoryEvent.UNDONE:
		if (WidgetUtils.inDisplayThread()) {
			Animation.run(150);
		}
		break;
	}
}
 

@Override
public void historyNotification(OperationHistoryEvent event) {
	int type = event.getEventType();
	if ((type == OperationHistoryEvent.DONE)
		|| (type == OperationHistoryEvent.REDONE)
		|| (type == OperationHistoryEvent.UNDONE)) {
		IUndoableOperation operation = event.getOperation();
		if ((undoContext == null) || operation.hasContext(undoContext) || operation.getContexts().length == 0) {
			Display display = WidgetUtils.getDisplay();
			display.asyncExec(new Runnable() {
				@Override
				public void run() {
					updateEnablement();
				}
			});
		}
	}
}
 

@Override
public void historyNotification(OperationHistoryEvent event) {
	int eventType = event.getEventType();
	if (eventType == OperationHistoryEvent.DONE ||
			eventType == OperationHistoryEvent.UNDONE ||
			eventType == OperationHistoryEvent.REDONE) {
		IEditorPart activeEditor = getActiveEditor();
		if (activeEditor != null) {
			WidgetUtils.runInDisplayThread(activeEditor.getSite().getShell(), new Runnable() {
				@Override
				public void run() {
					selectionChanged(activeSelectionProvider.getSelection());
				}
			});
		}
	}
}
 

public void historyNotification(OperationHistoryEvent event) {
	final int type = event.getEventType();
	switch (type) {
		case OperationHistoryEvent.UNDONE:
		case OperationHistoryEvent.REDONE:
		case OperationHistoryEvent.OPERATION_ADDED:
		case OperationHistoryEvent.OPERATION_REMOVED:
		case OperationHistoryEvent.OPERATION_NOT_OK:
			// if this is one of our operations
			if (event.getOperation().hasContext(this.context)) {
				this.update.update();
			}
	}
}
 

public void historyNotification(OperationHistoryEvent event) {
  IUndoableOperation op = event.getOperation();
  if (op instanceof TriggeredOperations) {
    op = ((TriggeredOperations) op).getTriggeringOperation();
  }
  UndoableOperation2ChangeAdapter changeOperation = null;
  if (op instanceof UndoableOperation2ChangeAdapter) {
    changeOperation = (UndoableOperation2ChangeAdapter) op;
  }
  if (changeOperation == null) return;
  Change change = changeOperation.getChange();
  switch (event.getEventType()) {
    case OperationHistoryEvent.ABOUT_TO_EXECUTE:
    case OperationHistoryEvent.ABOUT_TO_UNDO:
    case OperationHistoryEvent.ABOUT_TO_REDO:
      fireAboutToPerformChange(change);
      break;
    case OperationHistoryEvent.DONE:
    case OperationHistoryEvent.UNDONE:
    case OperationHistoryEvent.REDONE:
      fireChangePerformed(change);
      fireUndoStackChanged();
      fireRedoStackChanged();
      break;
    case OperationHistoryEvent.OPERATION_NOT_OK:
      fireChangePerformed(change);
      break;
    case OperationHistoryEvent.OPERATION_ADDED:
      // would be better to have different events for this
      fireUndoStackChanged();
      fireRedoStackChanged();
      break;
    case OperationHistoryEvent.OPERATION_REMOVED:
      // would be better to have different events for this
      fireUndoStackChanged();
      fireRedoStackChanged();
      break;
  }
}
 

public void aboutToNotify(OperationHistoryEvent event) {
  switch (event.getEventType()) {
    case OperationHistoryEvent.ABOUT_TO_EXECUTE:
    case OperationHistoryEvent.ABOUT_TO_UNDO:
    case OperationHistoryEvent.ABOUT_TO_REDO:
    case OperationHistoryEvent.DONE:
    case OperationHistoryEvent.UNDONE:
    case OperationHistoryEvent.REDONE:
    case OperationHistoryEvent.OPERATION_NOT_OK:
      ResourcesPlugin.getWorkspace().checkpoint(false);
      break;
  }
}
 

private void performHistoryNotification(final OperationHistoryEvent event) {
  RefactoringDescriptor descriptor = getRefactoringDescriptor(event.getOperation());
  if (descriptor != null) {
    RefactoringDescriptorProxyAdapter proxy = new RefactoringDescriptorProxyAdapter(descriptor);
    switch (event.getEventType()) {
      case OperationHistoryEvent.ABOUT_TO_EXECUTE:
        {
          if (checkDescriptor(descriptor, event.getOperation())) {
            fireRefactoringExecutionEvent(proxy, RefactoringExecutionEvent.ABOUT_TO_PERFORM);
          }
          break;
        }
      case OperationHistoryEvent.DONE:
        {
          if (!RefactoringDescriptor.ID_UNKNOWN.equals(descriptor.getID())) {
            long timeStamp =
                fOverrideTimeStamp >= 0 ? fOverrideTimeStamp : System.currentTimeMillis();
            descriptor.setTimeStamp(timeStamp);
          }

          fireRefactoringHistoryEvent(proxy, RefactoringHistoryEvent.PUSHED);
          fireRefactoringExecutionEvent(proxy, RefactoringExecutionEvent.PERFORMED);
          break;
        }
      case OperationHistoryEvent.ABOUT_TO_UNDO:
        {
          fireRefactoringExecutionEvent(proxy, RefactoringExecutionEvent.ABOUT_TO_UNDO);
          break;
        }
      case OperationHistoryEvent.UNDONE:
        {
          fireRefactoringHistoryEvent(proxy, RefactoringHistoryEvent.POPPED);
          fireRefactoringExecutionEvent(proxy, RefactoringExecutionEvent.UNDONE);
          break;
        }
      case OperationHistoryEvent.ABOUT_TO_REDO:
        {
          fireRefactoringExecutionEvent(proxy, RefactoringExecutionEvent.ABOUT_TO_REDO);
          break;
        }
      case OperationHistoryEvent.REDONE:
        {
          fireRefactoringHistoryEvent(proxy, RefactoringHistoryEvent.PUSHED);
          fireRefactoringExecutionEvent(proxy, RefactoringExecutionEvent.REDONE);
          break;
        }
    }
  }
}
 

@Override
public void historyNotification(OperationHistoryEvent event) {
	IUndoableOperation eventOperation = event.getOperation();
	IUndoContext inputUndoContext = getUndoContext();
	IUndoContext[] operationContexts = eventOperation.getContexts();
	boolean matches = false;
	for (IUndoContext operationContext : operationContexts) {
		matches = operationContext.matches(inputUndoContext);
		if (matches) {
			break;
		}
	}
	if (!matches) {
		return;
	}
	switch (event.getEventType()) {
	case OperationHistoryEvent.REDONE: {
		if (eventOperation == cleanStateOperation) {
			dirty = false;
			fireDirtyStateChanged();
		} else if (!dirty) {
			dirty = true;
			fireDirtyStateChanged();
		}
		break;
	}
	case OperationHistoryEvent.DONE: {
		if (!dirty) {
			dirty = true;
			fireDirtyStateChanged();
		}
		break;
	}
	case OperationHistoryEvent.UNDONE: {
		IUndoableOperation undoOperation = event.getHistory().getUndoOperation(inputUndoContext);
		if (undoOperation == cleanStateOperation) {
			dirty = false;
			fireDirtyStateChanged();
		} else if (!dirty) {
			dirty = true;
			fireDirtyStateChanged();
		}
		break;
	}
	default:
		// nothing to do yet
		break;
	}
}
 

@Override
public void historyNotification(final OperationHistoryEvent event) {
    if (event.getOperation() == theEditLabelOperation) {
        if (event.getEventType() == OperationHistoryEvent.UNDONE) {
            async(new Runnable() {
                @Override
                public void run() {
                    final IUndoableOperation[] theUndoHistory = theCommandStack.getOperationHistory()
                            .getUndoHistory(theCommandStack.getDefaultUndoContext());
                    if (theUndoHistory.length > 0
                            && theUndoHistory[theUndoHistory.length - 1] == theCreateElementOperation) {
                        theCommandStack.undo();
                    } else {
                        Activator.INSTANCE
                        .log("Unable to cascade the undo after the element label change was undone. The Reference Library Subset may be in an illegal state.");
                        stopListening();
                    }
                }
            });
        } else if (event.getEventType() == OperationHistoryEvent.OPERATION_REMOVED) {
            stopListening();
        }
    }
    if (event.getOperation() == theCreateElementOperation) {
        if (event.getEventType() == OperationHistoryEvent.REDONE) {
            async(new Runnable() {
                @Override
                public void run() {
                    final IUndoableOperation[] theRedoHistory = theCommandStack.getOperationHistory()
                            .getRedoHistory(theCommandStack.getDefaultUndoContext());
                    if (theRedoHistory.length > 0
                            && theRedoHistory[theRedoHistory.length - 1] == theEditLabelOperation) {
                        theCommandStack.redo();
                    } else {
                        Activator.INSTANCE
                        .log("Unable to cascade the redo after the create element change was redone. The Reference Library Subset may be in an illegal state.");
                        stopListening();
                    }
                }
            });
        } else if (event.getEventType() == OperationHistoryEvent.OPERATION_REMOVED) {
            stopListening();
        }
    }
}