org.eclipse.ui.operations.UndoRedoActionGroup#org.eclipse.core.commands.operations.IUndoContext源码实例Demo

/**
 * Constructs a new root entry.
 *
 * @param workbenchPart
 *            The {@link IWorkbenchPart} to adapt for an
 *            {@link IPropertySource}, in case no values are provided.
 * @param operationHistory
 *            The {@link IOperationHistory} to use.
 * @param undoContext
 *            The {@link IUndoContext} to use.
 */
public UndoablePropertySheetEntry(IWorkbenchPart workbenchPart,
		IOperationHistory operationHistory, IUndoContext undoContext) {
	this.workbenchPart = workbenchPart;
	this.operationHistory = operationHistory;
	this.undoContext = undoContext;
	this.operationHistoryListener = new IOperationHistoryListener() {

		@Override
		public void historyNotification(OperationHistoryEvent event) {
			refreshFromRoot();
		}
	};
	this.operationHistory
			.addOperationHistoryListener(operationHistoryListener);
}
 

/**
 * Constructs a new {@link UndoablePropertySheetPage} using the provided
 * {@link IOperationHistory}.
 *
 * @param operationHistory
 *            The {@link IOperationHistory} shared with the editor/view.
 * @param undoContext
 *            The {@link IUndoContext} shared with the editor/view.
 * @param workbenchPart
 *            The {@link IWorkbenchPart} this
 *            {@link UndoablePropertySheetPage} is related to. .
 *
 */
@Inject
public UndoablePropertySheetPage(@Assisted IWorkbenchPart workbenchPart,
		IOperationHistory operationHistory, IUndoContext undoContext) {
	this.workbenchPart = workbenchPart;
	this.operationHistory = operationHistory;
	this.undoContext = undoContext;
	this.operationHistoryListener = new IOperationHistoryListener() {

		@Override
		public void historyNotification(OperationHistoryEvent event) {
			if (event.getEventType() == OperationHistoryEvent.ABOUT_TO_REDO
					|| event.getEventType() == OperationHistoryEvent.ABOUT_TO_UNDO) {
				refresh();
			}
		}
	};
	operationHistory.addOperationHistoryListener(operationHistoryListener);
	setRootEntry(createRootEntry());
}
 

/**
 * Binds a factory for the creation of
 * {@link HistoryBasedDirtyStateProvider} as {@link IDirtyStateProvider}.
 */
protected void bindIDirtyStateProviderFactory() {
	binder().bind(IDirtyStateProviderFactory.class)
			.toInstance(new IDirtyStateProviderFactory() {

				@Override
				public IDirtyStateProvider create(
						IWorkbenchPart workbenchPart) {
					return new HistoryBasedDirtyStateProvider(
							(IOperationHistory) workbenchPart
									.getAdapter(IOperationHistory.class),
							(IUndoContext) workbenchPart
									.getAdapter(IUndoContext.class));
				}
			});
}
 

public JavaEditorBreadcrumbActionGroup(JavaEditor javaEditor, ISelectionProvider selectionProvider) {
	super(new ActionGroup[] {
			new BreadcrumbActionGroup(javaEditor),
			new UndoRedoActionGroup(javaEditor.getEditorSite(), (IUndoContext) ResourcesPlugin.getWorkspace().getAdapter(IUndoContext.class), true),
			new NewWizardsActionGroup(javaEditor.getEditorSite()),
			new JavaSearchActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new NavigateActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new CCPActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new GenerateBuildPathActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new GenerateActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new RefactorActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new BuildActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new ProjectActionGroup(javaEditor.getEditorSite(), selectionProvider),
			new WorkingSetActionGroup(javaEditor.getEditorSite(), selectionProvider)
	});
}
 

@Override
public boolean isEnabled() {
	final IEditorPart editor = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor() ;
	if(editor != null){
		final IOperationHistory history = (IOperationHistory) editor.getAdapter(IOperationHistory.class);
		final IUndoContext context = (IUndoContext) editor.getAdapter(IUndoContext.class);
		if(history != null && context != null){
			final IUndoableOperation[] undoHistory = history.getUndoHistory(context);
               if (undoHistory != null && undoHistory.length != 0) {
                   final IUndoableOperation ctxt = undoHistory[undoHistory.length - 1];
				final String ctxtLabel = ctxt.getLabel();
                   if(ctxtLabel != null && ctxtLabel.contains("Lane")){//Avoid Exception on undo //$NON-NLS-1$
					return false ;
				} else {
					return ctxt.canUndo();
				}
			}
		} else {
			return false;
		}
	}
	return false;
}
 

protected OperationHistoryListener installUndoRedoSupport(SourceViewer viewer, IDocument document, final EmbeddedEditorActions actions) {
	IDocumentUndoManager undoManager = DocumentUndoManagerRegistry.getDocumentUndoManager(document);
	final IUndoContext context = undoManager.getUndoContext();
	IOperationHistory operationHistory = PlatformUI.getWorkbench().getOperationSupport().getOperationHistory();
	OperationHistoryListener operationHistoryListener = new OperationHistoryListener(context, new IUpdate() {
		@Override
		public void update() {
			actions.updateAction(ITextEditorActionConstants.REDO);
			actions.updateAction(ITextEditorActionConstants.UNDO);
		}
	});
	operationHistory.addOperationHistoryListener(operationHistoryListener);
	return operationHistoryListener;
}
 

public void startRecording(XtextEditor editor) {
	this.editor = editor;
	ISourceViewer viewer = editor.getInternalSourceViewer();
	if (viewer instanceof ITextViewerExtension6) {
		IUndoManager undoManager = ((ITextViewerExtension6) viewer).getUndoManager();
		if (undoManager instanceof IUndoManagerExtension) {
			IUndoManagerExtension undoManagerExtension = (IUndoManagerExtension) undoManager;
			IUndoContext undoContext = undoManagerExtension.getUndoContext();
			IOperationHistory operationHistory = OperationHistoryFactory.getOperationHistory();
			startingUndoOperation = operationHistory.getUndoOperation(undoContext);
		}
	}
}
 

/**
 * Sets the {@link IUndoContext} that is used by this
 * {@link HistoricizingDomain} to the given value.
 *
 * @param undoContext
 *            The new {@link IUndoContext} for this domain.
 */
@Inject
public void setUndoContext(IUndoContext undoContext) {
	this.undoContext = undoContext;
	if (operationHistory != null && undoContext != null) {
		operationHistory.setLimit(undoContext, DEFAULT_UNDO_LIMIT);
	}
}
 

/**
 * Creates the actions for this editor and registers them in the editor's
 * site action bar.
 *
 */
protected void createActions() {
	undoRedoActionGroup = new UndoRedoActionGroup(getSite(),
			(IUndoContext) getAdapter(IUndoContext.class), true);

	deleteAction = new DeleteAction();
	getContentViewer().setAdapter(deleteAction);

	selectAllAction = new SelectAllAction();
	getContentViewer().setAdapter(selectAllAction);
}
 

/**
 * Create actions for this view and registers at the action bars of the
 * view's site.
 */
protected void createActions() {
	IViewSite site = getViewSite();
	IActionBars actionBars = site.getActionBars();
	undoRedoActionGroup = new UndoRedoActionGroup(getSite(),
			(IUndoContext) getAdapter(IUndoContext.class), true);
	undoRedoActionGroup.fillActionBars(actionBars);

	deleteAction = new DeleteAction();
	getContentViewer().setAdapter(deleteAction);
	actionBars.setGlobalActionHandler(ActionFactory.DELETE.getId(),
			deleteAction);

	selectAllAction = new SelectAllAction();
	getContentViewer().setAdapter(selectAllAction);
	actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(),
			selectAllAction);

	zoomActionGroup = new ZoomActionGroup(new FitToViewportAction());
	getContentViewer().setAdapter(zoomActionGroup);
	fitToViewportActionGroup = new FitToViewportActionGroup();
	getContentViewer().setAdapter(fitToViewportActionGroup);
	scrollActionGroup = new ScrollActionGroup();
	getContentViewer().setAdapter(scrollActionGroup);

	IToolBarManager mgr = actionBars.getToolBarManager();
	zoomActionGroup.fillActionBars(actionBars);
	mgr.add(new Separator());
	fitToViewportActionGroup.fillActionBars(actionBars);
	mgr.add(new Separator());
	scrollActionGroup.fillActionBars(actionBars);
}
 

@SuppressWarnings("rawtypes")
@Override
public Object getAdapter(final Class key) {
	// Provide a default selection provider (subclasses may overwrite by
	// handling the key and returning a different implementation
	// replace with binding
	if (ISelectionProvider.class.equals(key)) {
		if (selectionProvider != null) {
			return selectionProvider;
		}
	}
	// contribute to Properties view (only created if required)
	if (IPropertySheetPage.class.equals(key)) {
		if (propertySheetPage == null) {
			propertySheetPage = createPropertySheetPage();
		}
		if (propertySheetPage != null) {
			return propertySheetPage;
		}
	}
	if (IUndoContext.class.equals(key)) {
		if (domain instanceof HistoricizingDomain) {
			return ((HistoricizingDomain) domain).getUndoContext();
		}
	}
	if (IOperationHistory.class.equals(key)) {
		if (domain instanceof HistoricizingDomain) {
			return ((HistoricizingDomain) domain).getOperationHistory();
		}
	}
	return super.getAdapter(key);
}
 

/**
 * Creates a new {@link HistoryBasedDirtyStateProvider}.
 *
 * @param operationHistory
 *            The {@link IOperationHistory} to use.
 * @param undoContext
 *            The {@link IUndoContext} to evaluate.
 */
public HistoryBasedDirtyStateProvider(IOperationHistory operationHistory,
		IUndoContext undoContext) {
	this.operationHistory = operationHistory;
	this.undoContext = undoContext;
	if (undoContext == null) {
		throw new IllegalArgumentException(
				"WorkbenchPart needs to be adaptable to IUndoContext");
	}

	operationHistoryListener = createOperationHistoryListener();
	operationHistory.addOperationHistoryListener(operationHistoryListener);
}
 

/**
 * Binds a factory for the creation of
 * {@link HistoryBasedDirtyStateProvider} as
 * {@link IDirtyStateProvider}.
 */
protected void bindIDirtyStateProviderFactory() {
	binder().bind(IDirtyStateProviderFactory.class).toInstance(new IDirtyStateProviderFactory() {

		@Override
		public IDirtyStateProvider create(IWorkbenchPart workbenchPart) {
			return new HistoryBasedDirtyStateProvider(
					(IOperationHistory) workbenchPart.getAdapter(IOperationHistory.class),
					(IUndoContext) workbenchPart.getAdapter(IUndoContext.class));
		}
	});
}
 

protected IUndoContext getUndoContext() {
  IUndoContext _xblockexpression = null;
  {
    IEditorPart _editor = this.editor.getReference().getEditor(true);
    final ITextEditor ed = ((ITextEditor) _editor);
    final IDocument document = ed.getDocumentProvider().getDocument(ed.getEditorInput());
    final IDocumentUndoManager undoManager = DocumentUndoManagerRegistry.getDocumentUndoManager(document);
    _xblockexpression = undoManager.getUndoContext();
  }
  return _xblockexpression;
}
 

private IUndoContext getUndoContext() {
	if (getSourceViewer() instanceof ITextViewerExtension6) {
		IUndoManager undoManager = ((ITextViewerExtension6) getSourceViewer()).getUndoManager();
		if (undoManager instanceof IUndoManagerExtension)
			return ((IUndoManagerExtension) undoManager).getUndoContext();
	}
	return null;
}
 

/**
 * Creates a new <code>RefactorActionGroup</code>. The group requires
 * that the selection provided by the part's selection provider is of type <code>
 * org.eclipse.jface.viewers.IStructuredSelection</code>.
 *
 * @param part the view part that owns this action group
 */
public RefactorActionGroup(IViewPart part) {
	this(part.getSite(), null);

	IUndoContext workspaceContext= (IUndoContext)ResourcesPlugin.getWorkspace().getAdapter(IUndoContext.class);
	fUndoRedoActionGroup= new UndoRedoActionGroup(part.getViewSite(), workspaceContext, true);

	installQuickAccessAction();
}
 

public SendTOTmOperation(String label, NatTable natTable, List<String> rowIdList, XLFHandler handler, String state) {
	super(label);
	IUndoContext context = (IUndoContext) natTable.getData(IUndoContext.class.getName());
	addContext(context);
	this.table = natTable;
	this.rowIdList = rowIdList;
	this.handler = handler;
	this.state = state;
	this.oldState = handler.getTuPropValue(rowIdList, "hs:send-to-tm");
}
 

public NeedsReviewOperation(String label, NatTable natTable, List<String> rowIdList, XLFHandler handler, String state) {
	super(label);
	IUndoContext context = (IUndoContext) natTable.getData(IUndoContext.class.getName());
	addContext(context);
	this.table = natTable;
	this.rowIdList = rowIdList;
	this.handler = handler;
	this.state = state;
	this.oldState = handler.getTuPropValue(rowIdList, "hs:needs-review");
}
 

public SplitSegmentOperation(String label, XLIFFEditorImplWithNatTable xliffEditor, XLFHandler handler,
		int rowIndex, int offset) {
	super(label);
	this.xliffEditor = xliffEditor;
	IUndoContext context = (IUndoContext) xliffEditor.getTable().getData(IUndoContext.class.getName());
	addContext(context);
	this.handler = handler;
	this.offset = offset;
	this.rowIndex = rowIndex;
	this.rowId = handler.getRowId(rowIndex);
}
 

private UpdateSegmentsOperation(XLIFFEditorImplWithNatTable xliffEditor, XLFHandler handler, List<String> rowIds,
		int column, boolean approved, String matchType, String quality) {
	super("Update Segments");
	this.xliffEditor = xliffEditor;
	this.table = xliffEditor.getTable();
	IUndoContext undoContext = (IUndoContext) table.getData(IUndoContext.class.getName());
	addContext(undoContext); // 绑定上下文
	this.handler = handler;
	this.rowIds = rowIds;
	this.approved = approved;
	segmentCache = handler.getTuNodes(rowIds); // 缓存未修改前的文本段
	this.matchType = matchType;
	this.quality = quality;
}
 

public MergeSegmentOperation(String label, XLIFFEditorImplWithNatTable xliffEditor, XLFHandler handler, List<String> rowIdList) {
	super(label);
	this.xliffEditor = xliffEditor;
	NatTable table = xliffEditor.getTable();
	IUndoContext context = (IUndoContext) table.getData(IUndoContext.class.getName());
	addContext(context);
	this.rowIdList = rowIdList;
	this.handler = handler;
	oldSegFragMap = new HashMap<String, String>();
}
 

/**
 * 
 * @param label
 * @param natTable
 * @param rowIdList
 * @param handler
 * @param lock
 */
public LockOperation(String label, NatTable natTable, List<String> rowIdList, XLFHandler handler,
		boolean lock) {
	super(label);
	IUndoContext context = (IUndoContext) natTable.getData(IUndoContext.class.getName());
	addContext(context);
	this.table = natTable;
	this.rowIdList = rowIdList;
	this.handler = handler;
	this.lock = lock;
}
 

public RemoveAllTagsOperation(String label, NatTable table, XLFHandler handler, List<String> rowIds) {
	super(label);
	IUndoContext context = (IUndoContext) table.getData(IUndoContext.class.getName());
	addContext(context);
	this.table = table;
	this.handler = handler;
	this.rowIds = rowIds;
}
 

public UpdateDataOperation(NatTable table, DataLayer dataLayer, UpdateDataAndAutoResizeCommand command) {
		super("Typing");
		IUndoContext undoContext = (IUndoContext) table.getData(IUndoContext.class.getName());
		addContext(undoContext);
		Object currentValue = dataLayer.getDataProvider().getDataValue(command.getColumnPosition(), command.getRowPosition());
//		Object currentValue = dataLayer.getDataValueByPosition(command2.getColumnPosition(), command2.getRowPosition());
		oldValue = currentValue == null ? new UpdateDataBean() : new UpdateDataBean((String) currentValue, null, null);
		this.dataLayer = dataLayer;
		this.command = command;
		this.table = table;
		viewportLayer = LayerUtil.getLayer(table, ViewportLayer.class);
	}
 

@Override
public void runWithEvent(Event event) {
	if (viewer != null && !viewer.getTextWidget().isDisposed()) {
		XLIFFEditorImplWithNatTable xliffEditor = XLIFFEditorImplWithNatTable.getCurrent();
		// 先保存在撤销，除非以后取消两种模式，否则不要删除此判断
		if (viewer.canDoOperation(ITextOperationTarget.UNDO)) {
			HsMultiActiveCellEditor.commit(true);
		}
		IOperationHistory history = OperationHistoryFactory.getOperationHistory();
		IUndoContext undoContext = (IUndoContext) xliffEditor.getTable().getData(IUndoContext.class.getName());
		if (history.canUndo(undoContext)) {
			try {
				history.undo(undoContext, null, null);
				undoBean.setCrosseStep(undoBean.getCrosseStep() + 1);
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		XLIFFEditorImplWithNatTable.getCurrent().redraw();
		updateActionsEnableState();
		return;
	}
	if (undoAction != null) {
		undoAction.runWithEvent(event);
		return;
	}
}
 

public void runWithEvent(Event event) {
	if (viewer != null && !viewer.getTextWidget().isDisposed()) {
		// 如果跨越焦点撤销，则先撤销非焦点
		try {
			IOperationHistory history = OperationHistoryFactory.getOperationHistory();
			IUndoContext undoContext = (IUndoContext) XLIFFEditorImplWithNatTable.getCurrent().getTable()
					.getData(IUndoContext.class.getName());
			history.redo(undoContext, null, null);
			// int crossSegment = undoBean.getCrosseStep();
			// if (crossSegment > 0) {
			// history.redo(undoContext, null, null);
			// undoBean.setCrosseStep(crossSegment - 1);
			// undoBean.setSaveStatus(-1);
			// } else if (undoBean.getSaveStatus() == -1) {
			// XLIFFEditorImplWithNatTable.getCurrent().jumpToRow(undoBean.getUnSaveRow());
			// viewer.setText(undoBean.getUnSaveText());
			// undoBean.setCrosseStep(0);
			// undoBean.setSaveStatus(0);
			// } else {
			// viewer.doOperation(ITextOperationTarget.REDO);
			// }
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		System.out.println(undoBean.getCrosseStep());
		updateActionsEnableState();
		return;
	}
	if (redoAction != null) {
		redoAction.runWithEvent(event);
		return;
	}
}
 

private void installUndoRedoSupport() {
	IUndoContext undoContext = ((IUndoManagerExtension) queryViewer.getUndoManager()).getUndoContext();

	UndoActionHandler undoAction = new UndoActionHandler(getSite(), undoContext);
	RedoActionHandler redoAction = new RedoActionHandler(getSite(), undoContext);

	undoAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_UNDO);
	redoAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_REDO);

	IActionBars actionBars = getEditor().getEditorSite().getActionBars();
	actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);
	actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);

	actionBars.updateActionBars();
}
 

public void runWithEvent(Event event) {
	TeActiveCellEditor.commit();
	IOperationHistory history = OperationHistoryFactory.getOperationHistory();
	IUndoContext context = PlatformUI.getWorkbench().getOperationSupport().getUndoContext();
	if (history.canUndo(context)) {
		try {
			history.undo(context, null, null);
			updateActionsEnableState();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}
 

/**
 * Update the state.
 */
public void updateEnabledState() {
	IOperationHistory opHisotry = OperationHistoryFactory.getOperationHistory();
	IUndoContext context = PlatformUI.getWorkbench().getOperationSupport().getUndoContext();
	if (opHisotry.canUndo(context)) {
		setEnabled(true);
		return;
	}
	if (viewer != null && !viewer.getTextWidget().isDisposed()) {
		setEnabled(viewer.canDoOperation(ITextOperationTarget.UNDO));
		return;
	}
	setEnabled(false);
}
 

public void runWithEvent(Event event) {
	TeActiveCellEditor.commit();
	IOperationHistory history = OperationHistoryFactory.getOperationHistory();
	IUndoContext context = PlatformUI.getWorkbench().getOperationSupport().getUndoContext();
	if (history.canRedo(context)) {
		try {
			history.redo(context, null, null);
			updateActionsEnableState();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}