Java OperationHistoryEvent.OPERATION_REMOVED属性代码示例

@Override
	public void historyNotification(OperationHistoryEvent event) {
		
		IUndoableOperation op = event.getOperation();
		String typeString = decodeEventType(event.getEventType());
//		System.out.println("type='"+typeString+"' operation='"+op+"' of type '"+op.getClass().getName()+"' e="+op.canExecute()+" u="+op.canUndo()+" r="+op.canRedo());
//		for(IUndoContext c : op.getContexts()) {
//			System.out.println("\t"+c.getLabel());
//		}
		
		switch(event.getEventType()) {
			case OperationHistoryEvent.OPERATION_ADDED:
			case OperationHistoryEvent.OPERATION_CHANGED:
			case OperationHistoryEvent.OPERATION_REMOVED:
			case OperationHistoryEvent.ABOUT_TO_EXECUTE:
			case OperationHistoryEvent.ABOUT_TO_REDO:
			case OperationHistoryEvent.ABOUT_TO_UNDO:
				break;
			default:
				EnsembleUsageLogger.logUsage(op.getLabel() + " - " + typeString + "\n" + op.toString());
		}
		
	}
 

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;
}
 

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;
  }
}
 

@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();
        }
    }
}