/*******************************************************************************
* Copyright (c) 2006 Business Objects Software Limited and others.
* All rights reserved.
* This file is 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:
* Business Objects Software Limited - initial API and implementation based on Eclipse 3.1.2 code for
* /org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/SmartBackspaceManager.java
* Eclipse source is available at: http://www.eclipse.org/downloads/
*******************************************************************************/
/*
* SmartBackspaceManager.java
* Creation date: Feb 15, 2006.
* By: Edward Lam
*/
package org.openquark.cal.eclipse.ui.text;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.ITextViewerExtension;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.VerifyKeyListener;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.TextEdit;
import org.openquark.cal.eclipse.ui.text.TypingRun.ChangeType;
/**
* Installs as a verify key listener on a viewer and overwrites the behaviour
* of the backspace key. Clients may register undo specifications for certain
* offsets in a document. The <code>SmartBackspaceManager</code> will manage the
* specfications and execute the contained <code>TextEdit</code>s when backspace
* is pressed at the given offset and the specification is still valid.
* <p>
* Undo specifications are removed after a number of typing runs.
* </p>
*
* @author Edward Lam
*/
public class SmartBackspaceManager {
/* independent of JDT - may be moved to jface.text */
/**
* An undo specification describes the change that should be executed if
* backspace is pressed at its trigger offset.
*
* @author Edward Lam
*/
public static final class UndoSpec {
private final int triggerOffset;
private final IRegion selection;
private final TextEdit[] undoEdits;
private final UndoSpec child;
int lives;
/**
* Creates a new spec. A specification consists of a number of
* <code>TextEdit</code> s that will be executed when backspace is
* pressed at <code>triggerOffset</code>. The spec will be removed
* when it is executed, or if more than <code>lives</code>
* <code>TypingRun</code>s have ended after registering the spec.
* <p>
* Optionally, a child specification can be registered. After executing
* the spec, the child spec will be registered with the manager. This allows
* to create chains of <code>UndoSpec</code>s that will be executed upon
* repeated pressing of backspace.
* </p>
*
* @param triggerOffset the offset where this spec is active
* @param selection the selection after executing the undo spec
* @param edits the <code>TextEdit</code> s to perform when executing
* the spec
* @param lives the number of <code>TypingRun</code> s before removing
* the spec
* @param child a child specification that will be registered after
* executing this spec, or <code>null</code>
*/
public UndoSpec(int triggerOffset, IRegion selection, TextEdit[] edits, int lives, UndoSpec child) {
Assert.isLegal(triggerOffset >= 0);
Assert.isLegal(selection != null);
Assert.isLegal(lives >= 0);
Assert.isLegal(edits != null);
Assert.isLegal(edits.length > 0);
for (final TextEdit edit : edits) {
Assert.isLegal(edit != null);
}
this.triggerOffset = triggerOffset;
this.selection = selection;
this.undoEdits = edits;
this.lives = lives;
this.child = child;
}
}
private class BackspaceListener implements VerifyKeyListener {
/*
* @see org.eclipse.swt.custom.VerifyKeyListener#verifyKey(org.eclipse.swt.events.VerifyEvent)
*/
public void verifyKey(VerifyEvent event) {
if (fViewer != null && isBackspace(event)) {
int offset = getCaretOffset();
UndoSpec spec = removeEdit(offset);
if (spec != null) {
try {
beginChange();
for (final TextEdit undoEdit : spec.undoEdits) {
undoEdit.apply(getDocument(), TextEdit.UPDATE_REGIONS);
}
fViewer.setSelectedRange(spec.selection.getOffset(), spec.selection.getLength());
if (spec.child != null) {
register(spec.child);
}
} catch (MalformedTreeException e) {
// fall back to standard bs
return;
} catch (BadLocationException e) {
// fall back to standard bs
return;
} finally {
endChange();
}
event.doit = false;
}
}
}
private void beginChange() {
ITextViewer viewer = fViewer;
if (viewer instanceof TextViewer) {
TextViewer v = (TextViewer)viewer;
v.getRewriteTarget().beginCompoundChange();
v.setRedraw(false);
}
}
private void endChange() {
ITextViewer viewer = fViewer;
if (viewer instanceof TextViewer) {
TextViewer v = (TextViewer)viewer;
v.getRewriteTarget().endCompoundChange();
v.setRedraw(true);
}
}
private boolean isBackspace(VerifyEvent event) {
return event.doit == true && event.character == SWT.BS && event.stateMask == 0;
}
private int getCaretOffset() {
ITextViewer viewer = fViewer;
Point point = viewer.getSelectedRange();
return point.x;
}
}
private ITextViewer fViewer;
private BackspaceListener fBackspaceListener;
private Map<Integer, UndoSpec> fSpecs;
private TypingRunDetector fRunDetector;
private ITypingRunListener fRunListener;
/**
* Registers an undo specification with this manager.
*
* @param spec the specification to register
* @throws IllegalStateException if the manager is not installed
*/
public void register(UndoSpec spec) {
if (fViewer == null) {
throw new IllegalStateException();
}
ensureListenerInstalled();
addEdit(spec);
}
private void addEdit(UndoSpec spec) {
Integer i = Integer.valueOf(spec.triggerOffset);
fSpecs.put(i, spec);
}
private UndoSpec removeEdit(int offset) {
Integer i = Integer.valueOf(offset);
UndoSpec spec = fSpecs.remove(i);
return spec;
}
private void ensureListenerInstalled() {
if (fBackspaceListener == null) {
fBackspaceListener = new BackspaceListener();
ITextViewer viewer = fViewer;
if (viewer instanceof ITextViewerExtension) {
((ITextViewerExtension)viewer).prependVerifyKeyListener(fBackspaceListener);
} else {
viewer.getTextWidget().addVerifyKeyListener(fBackspaceListener);
}
}
}
private void ensureListenerRemoved() {
if (fBackspaceListener != null) {
ITextViewer viewer = fViewer;
if (viewer instanceof ITextViewerExtension) {
((ITextViewerExtension)viewer).removeVerifyKeyListener(fBackspaceListener);
} else {
viewer.getTextWidget().removeVerifyKeyListener(fBackspaceListener);
}
fBackspaceListener = null;
}
}
private IDocument getDocument() {
return fViewer.getDocument();
}
/**
* Installs the receiver on a text viewer.
*
* @param viewer
*/
public void install(ITextViewer viewer) {
Assert.isLegal(viewer != null);
fViewer = viewer;
fSpecs = new HashMap<Integer, UndoSpec>();
fRunDetector = new TypingRunDetector();
fRunDetector.install(viewer);
fRunListener = new ITypingRunListener() {
/*
* @see org.eclipse.jface.text.TypingRunDetector.ITypingRunListener#typingRunStarted(org.eclipse.jface.text.TypingRunDetector.TypingRun)
*/
public void typingRunStarted(TypingRun run) {
}
/*
* @see org.eclipse.jface.text.TypingRunDetector.ITypingRunListener#typingRunEnded(org.eclipse.jface.text.TypingRunDetector.TypingRun)
*/
public void typingRunEnded(TypingRun run, ChangeType reason) {
if (reason == TypingRun.SELECTION) {
fSpecs.clear();
} else {
prune();
}
}
};
fRunDetector.addTypingRunListener(fRunListener);
}
private void prune() {
for (Iterator<UndoSpec> it = fSpecs.values().iterator(); it.hasNext();) {
UndoSpec spec = it.next();
if (--spec.lives < 0) {
it.remove();
}
}
}
/**
* Uninstalls the receiver. No undo specifications may be registered on an
* uninstalled manager.
*/
public void uninstall() {
if (fViewer != null) {
fRunDetector.removeTypingRunListener(fRunListener);
fRunDetector.uninstall();
fRunDetector = null;
ensureListenerRemoved();
fViewer = null;
}
}
}