Rename HTML editor to Smarty editor
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / ui / text / SmartBackspaceManager.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  *
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.ui.text;
12
13 import java.util.HashMap;
14 import java.util.Iterator;
15 import java.util.Map;
16
17 import net.sourceforge.phpdt.internal.ui.text.TypingRun.ChangeType;
18
19 import org.eclipse.jface.text.Assert;
20 import org.eclipse.jface.text.BadLocationException;
21 import org.eclipse.jface.text.IDocument;
22 import org.eclipse.jface.text.IRegion;
23 import org.eclipse.jface.text.ITextViewer;
24 import org.eclipse.jface.text.ITextViewerExtension;
25 import org.eclipse.jface.text.TextViewer;
26 import org.eclipse.swt.SWT;
27 import org.eclipse.swt.custom.VerifyKeyListener;
28 import org.eclipse.swt.events.VerifyEvent;
29 import org.eclipse.swt.graphics.Point;
30 import org.eclipse.text.edits.MalformedTreeException;
31 import org.eclipse.text.edits.TextEdit;
32
33
34
35 /**
36  * Installs as a verify key listener on a viewer and overwrites the behaviour
37  * of the backspace key. Clients may register undo specifications for certain
38  * offsets in a document. The <code>SmartBackspaceManager</code> will manage the
39  * specfications and execute the contained <code>TextEdit</code>s when backspace
40  * is pressed at the given offset and the specification is still valid.
41  * <p>
42  * Undo specifications are removed after a number of typing runs.
43  * </p>
44  *  
45  * @since 3.0
46  */
47 public class SmartBackspaceManager {
48         /* independent of JDT - may be moved to jface.text */
49
50         /**
51          * An undo specification describes the change that should be executed if
52          * backspace is pressed at its trigger offset.
53          *  
54          * @since 3.0
55          */
56         public static final class UndoSpec {
57                 private final int triggerOffset;
58                 private final IRegion selection;
59                 private final TextEdit[] undoEdits;
60                 private final UndoSpec child;
61                 int lives;
62                 
63                 /**
64                  * Creates a new spec. A specification consists of a number of
65                  * <code>TextEdit</code> s that will be executed when backspace is
66                  * pressed at <code>triggerOffset</code>. The spec will be removed
67                  * when it is executed, or if more than <code>lives</code>
68                  * <code>TypingRun</code>s have ended after registering the spec.
69                  * <p>
70                  * Optionally, a child specification can be registered. After executing
71                  * the spec, the child spec will be registered with the manager. This allows
72                  * to create chains of <code>UndoSpec</code>s that will be executed upon
73                  * repeated pressing of backspace.
74                  * </p>
75                  * 
76                  * @param triggerOffset the offset where this spec is active
77                  * @param selection the selection after executing the undo spec
78                  * @param edits the <code>TextEdit</code> s to perform when executing
79                  *        the spec
80                  * @param lives the number of <code>TypingRun</code> s before removing
81                  *        the spec
82                  * @param child a child specification that will be registered after
83                  *        executing this spec, or <code>null</code>
84                  */
85                 public UndoSpec(int triggerOffset, IRegion selection, TextEdit[] edits, int lives, UndoSpec child) {
86                         Assert.isLegal(triggerOffset >= 0);
87                         Assert.isLegal(selection != null);
88                         Assert.isLegal(lives >= 0);
89                         Assert.isLegal(edits != null);
90                         Assert.isLegal(edits.length > 0);
91                         for (int i= 0; i < edits.length; i++) {
92                                 Assert.isLegal(edits[i] != null);
93                         }
94                         
95                         this.triggerOffset= triggerOffset;
96                         this.selection= selection;
97                         this.undoEdits= edits;
98                         this.lives= lives;
99                         this.child= child;
100                 }
101         }
102
103
104         private class BackspaceListener implements VerifyKeyListener {
105
106                 /*
107                  * @see org.eclipse.swt.custom.VerifyKeyListener#verifyKey(org.eclipse.swt.events.VerifyEvent)
108                  */
109                 public void verifyKey(VerifyEvent event) {
110                         if (fViewer != null && isBackspace(event)) {
111                                 int offset= getCaretOffset();
112                                 UndoSpec spec= removeEdit(offset);
113                                 if (spec != null) {
114                                         try {
115                                                 beginChange();
116                                                 for (int i= 0; i < spec.undoEdits.length; i++) {
117                                                         spec.undoEdits[i].apply(getDocument(), TextEdit.UPDATE_REGIONS);
118                                                 }
119                                                 fViewer.setSelectedRange(spec.selection.getOffset(), spec.selection.getLength());
120                                                 if (spec.child != null)
121                                                         register(spec.child);
122                                         } catch (MalformedTreeException e) {
123                                                 // fall back to standard bs
124                                                 return;
125                                         } catch (BadLocationException e) {
126                                                 // fall back to standard bs
127                                                 return;
128                                         } finally {
129                                                 endChange();
130                                         }
131                                         event.doit= false;
132                                 }
133                                 
134                         }
135                 }
136
137                 private void beginChange() {
138                         ITextViewer viewer= fViewer;
139                         if (viewer instanceof TextViewer) {
140                                 TextViewer v= (TextViewer) viewer;
141                                 v.getRewriteTarget().beginCompoundChange();
142                                 v.setRedraw(false);
143                         }
144                 }
145
146                 private void endChange() {
147                         ITextViewer viewer= fViewer;
148                         if (viewer instanceof TextViewer) {
149                                 TextViewer v= (TextViewer) viewer;
150                                 v.getRewriteTarget().endCompoundChange();
151                                 v.setRedraw(true);
152                         }
153                 }
154
155                 private boolean isBackspace(VerifyEvent event) {
156                         return event.doit == true && event.character == SWT.BS && event.stateMask == 0;
157                 }
158
159                 private int getCaretOffset() {
160                         ITextViewer viewer= fViewer;
161                         Point point= viewer.getSelectedRange();
162                         return point.x;
163                 }
164
165         }
166         
167         private ITextViewer fViewer;
168         private BackspaceListener fBackspaceListener;
169         private Map fSpecs;
170         private TypingRunDetector fRunDetector;
171         private ITypingRunListener fRunListener;
172
173         /**
174          * Registers an undo specification with this manager.
175          * 
176          * @param spec the specification to register
177          * @throws IllegalStateException if the manager is not installed
178          */
179         public void register(UndoSpec spec) {
180                 if (fViewer == null)
181                         throw new IllegalStateException();
182                 
183                 ensureListenerInstalled();
184                 addEdit(spec);
185         }
186
187         private void addEdit(UndoSpec spec) {
188                 Integer i= new Integer(spec.triggerOffset);
189                 fSpecs.put(i, spec);
190         }
191         
192         private UndoSpec removeEdit(int offset) {
193                 Integer i= new Integer(offset);
194                 UndoSpec spec= (UndoSpec) fSpecs.remove(i);
195                 return spec;
196         }
197
198         private void ensureListenerInstalled() {
199                 if (fBackspaceListener == null) {
200                         fBackspaceListener= new BackspaceListener();
201                         ITextViewer viewer= fViewer;
202                         if (viewer instanceof ITextViewerExtension)
203                                 ((ITextViewerExtension) viewer).prependVerifyKeyListener(fBackspaceListener);
204                         else
205                                 viewer.getTextWidget().addVerifyKeyListener(fBackspaceListener);
206                 }
207         }
208
209         private void ensureListenerRemoved() {
210                 if (fBackspaceListener != null) {
211                         ITextViewer viewer= fViewer;
212                         if (viewer instanceof ITextViewerExtension)
213                                 ((ITextViewerExtension) viewer).removeVerifyKeyListener(fBackspaceListener);
214                         else
215                                 viewer.getTextWidget().removeVerifyKeyListener(fBackspaceListener);
216                         fBackspaceListener= null;
217                 }
218         }
219
220         private IDocument getDocument() {
221                 return fViewer.getDocument();
222         }
223
224         /**
225          * Installs the receiver on a text viewer.
226          * 
227          * @param viewer
228          */
229         public void install(ITextViewer viewer) {
230                 Assert.isLegal(viewer != null);
231                 
232                 fViewer= viewer;
233                 fSpecs= new HashMap();
234                 fRunDetector= new TypingRunDetector();
235                 fRunDetector.install(viewer);
236                 fRunListener= new ITypingRunListener() {
237
238                         /*
239                          * @see org.eclipse.jface.text.TypingRunDetector.ITypingRunListener#typingRunStarted(org.eclipse.jface.text.TypingRunDetector.TypingRun)
240                          */
241                         public void typingRunStarted(TypingRun run) {
242                         }
243
244                         /*
245                          * @see org.eclipse.jface.text.TypingRunDetector.ITypingRunListener#typingRunEnded(org.eclipse.jface.text.TypingRunDetector.TypingRun)
246                          */
247                         public void typingRunEnded(TypingRun run, ChangeType reason) {
248                                 if (reason == TypingRun.SELECTION)
249                                         fSpecs.clear();
250                                 else
251                                         prune();
252                         }
253                 };
254                 fRunDetector.addTypingRunListener(fRunListener);
255         }
256         
257         private void prune() {
258                 for (Iterator it= fSpecs.values().iterator(); it.hasNext();) {
259                         UndoSpec spec= (UndoSpec) it.next();
260                         if (--spec.lives < 0)
261                                 it.remove();
262                 }
263         }
264         
265         /**
266          * Uninstalls the receiver. No undo specifications may be registered on an
267          * uninstalled manager.
268          */
269         public void uninstall() {
270                 if (fViewer != null) {
271                         fRunDetector.removeTypingRunListener(fRunListener);
272                         fRunDetector.uninstall();
273                         fRunDetector= null;
274                         ensureListenerRemoved();
275                         fViewer= null;
276                 }
277         }
278 }