Mercurial > projects > dwt-addons
annotate dwtx/jface/text/DefaultUndoManager.d @ 156:a9566845f1cb
...
| author | Frank Benoit <benoit@tionex.de> |
|---|---|
| date | Mon, 25 Aug 2008 19:03:46 +0200 |
| parents | f70d9508c95c |
| children | 7926b636c282 |
| rev | line source |
|---|---|
| 129 | 1 /******************************************************************************* |
| 2 * Copyright (c) 2000, 2008 IBM Corporation and others. | |
| 3 * All rights reserved. This program and the accompanying materials | |
| 4 * are made available under the terms of the Eclipse Public License v1.0 | |
| 5 * which accompanies this distribution, and is available at | |
| 6 * http://www.eclipse.org/legal/epl-v10.html | |
| 7 * | |
| 8 * Contributors: | |
| 9 * IBM Corporation - initial API and implementation | |
| 10 * Port to the D programming language: | |
| 11 * Frank Benoit <benoit@tionex.de> | |
| 12 *******************************************************************************/ | |
| 13 | |
| 131 | 14 |
| 151 | 15 module dwtx.jface.text.DefaultUndoManager; |
| 16 | |
| 131 | 17 import dwtx.jface.text.IDocumentPartitioningListener; // packageimport |
| 18 import dwtx.jface.text.DefaultTextHover; // packageimport | |
| 19 import dwtx.jface.text.AbstractInformationControl; // packageimport | |
| 20 import dwtx.jface.text.TextUtilities; // packageimport | |
| 21 import dwtx.jface.text.IInformationControlCreatorExtension; // packageimport | |
| 22 import dwtx.jface.text.AbstractInformationControlManager; // packageimport | |
| 23 import dwtx.jface.text.ITextViewerExtension2; // packageimport | |
| 24 import dwtx.jface.text.IDocumentPartitioner; // packageimport | |
| 25 import dwtx.jface.text.DefaultIndentLineAutoEditStrategy; // packageimport | |
| 26 import dwtx.jface.text.ITextSelection; // packageimport | |
| 27 import dwtx.jface.text.Document; // packageimport | |
| 28 import dwtx.jface.text.FindReplaceDocumentAdapterContentProposalProvider; // packageimport | |
| 29 import dwtx.jface.text.ITextListener; // packageimport | |
| 30 import dwtx.jface.text.BadPartitioningException; // packageimport | |
| 31 import dwtx.jface.text.ITextViewerExtension5; // packageimport | |
| 32 import dwtx.jface.text.IDocumentPartitionerExtension3; // packageimport | |
| 33 import dwtx.jface.text.IUndoManager; // packageimport | |
| 34 import dwtx.jface.text.ITextHoverExtension2; // packageimport | |
| 35 import dwtx.jface.text.IRepairableDocument; // packageimport | |
| 36 import dwtx.jface.text.IRewriteTarget; // packageimport | |
| 37 import dwtx.jface.text.DefaultPositionUpdater; // packageimport | |
| 38 import dwtx.jface.text.RewriteSessionEditProcessor; // packageimport | |
| 39 import dwtx.jface.text.TextViewerHoverManager; // packageimport | |
| 40 import dwtx.jface.text.DocumentRewriteSession; // packageimport | |
| 41 import dwtx.jface.text.TextViewer; // packageimport | |
| 42 import dwtx.jface.text.ITextViewerExtension8; // packageimport | |
| 43 import dwtx.jface.text.RegExMessages; // packageimport | |
| 44 import dwtx.jface.text.IDelayedInputChangeProvider; // packageimport | |
| 45 import dwtx.jface.text.ITextOperationTargetExtension; // packageimport | |
| 46 import dwtx.jface.text.IWidgetTokenOwner; // packageimport | |
| 47 import dwtx.jface.text.IViewportListener; // packageimport | |
| 48 import dwtx.jface.text.GapTextStore; // packageimport | |
| 49 import dwtx.jface.text.MarkSelection; // packageimport | |
| 50 import dwtx.jface.text.IDocumentPartitioningListenerExtension; // packageimport | |
| 51 import dwtx.jface.text.IDocumentAdapterExtension; // packageimport | |
| 52 import dwtx.jface.text.IInformationControlExtension; // packageimport | |
| 53 import dwtx.jface.text.IDocumentPartitioningListenerExtension2; // packageimport | |
| 54 import dwtx.jface.text.DefaultDocumentAdapter; // packageimport | |
| 55 import dwtx.jface.text.ITextViewerExtension3; // packageimport | |
| 56 import dwtx.jface.text.IInformationControlCreator; // packageimport | |
| 57 import dwtx.jface.text.TypedRegion; // packageimport | |
| 58 import dwtx.jface.text.ISynchronizable; // packageimport | |
| 59 import dwtx.jface.text.IMarkRegionTarget; // packageimport | |
| 60 import dwtx.jface.text.TextViewerUndoManager; // packageimport | |
| 61 import dwtx.jface.text.IRegion; // packageimport | |
| 62 import dwtx.jface.text.IInformationControlExtension2; // packageimport | |
| 63 import dwtx.jface.text.IDocumentExtension4; // packageimport | |
| 64 import dwtx.jface.text.IDocumentExtension2; // packageimport | |
| 65 import dwtx.jface.text.IDocumentPartitionerExtension2; // packageimport | |
| 66 import dwtx.jface.text.Assert; // packageimport | |
| 67 import dwtx.jface.text.DefaultInformationControl; // packageimport | |
| 68 import dwtx.jface.text.IWidgetTokenOwnerExtension; // packageimport | |
| 69 import dwtx.jface.text.DocumentClone; // packageimport | |
| 70 import dwtx.jface.text.IFindReplaceTarget; // packageimport | |
| 71 import dwtx.jface.text.IAutoEditStrategy; // packageimport | |
| 72 import dwtx.jface.text.ILineTrackerExtension; // packageimport | |
| 73 import dwtx.jface.text.IUndoManagerExtension; // packageimport | |
| 74 import dwtx.jface.text.TextSelection; // packageimport | |
| 75 import dwtx.jface.text.DefaultAutoIndentStrategy; // packageimport | |
| 76 import dwtx.jface.text.IAutoIndentStrategy; // packageimport | |
| 77 import dwtx.jface.text.IPainter; // packageimport | |
| 78 import dwtx.jface.text.IInformationControl; // packageimport | |
| 79 import dwtx.jface.text.IInformationControlExtension3; // packageimport | |
| 80 import dwtx.jface.text.ITextViewerExtension6; // packageimport | |
| 81 import dwtx.jface.text.IInformationControlExtension4; // packageimport | |
| 82 import dwtx.jface.text.DefaultLineTracker; // packageimport | |
| 83 import dwtx.jface.text.IDocumentInformationMappingExtension; // packageimport | |
| 84 import dwtx.jface.text.IRepairableDocumentExtension; // packageimport | |
| 85 import dwtx.jface.text.ITextHover; // packageimport | |
| 86 import dwtx.jface.text.FindReplaceDocumentAdapter; // packageimport | |
| 87 import dwtx.jface.text.ILineTracker; // packageimport | |
| 88 import dwtx.jface.text.Line; // packageimport | |
| 89 import dwtx.jface.text.ITextViewerExtension; // packageimport | |
| 90 import dwtx.jface.text.IDocumentAdapter; // packageimport | |
| 91 import dwtx.jface.text.TextEvent; // packageimport | |
| 92 import dwtx.jface.text.BadLocationException; // packageimport | |
| 93 import dwtx.jface.text.AbstractDocument; // packageimport | |
| 94 import dwtx.jface.text.AbstractLineTracker; // packageimport | |
| 95 import dwtx.jface.text.TreeLineTracker; // packageimport | |
| 96 import dwtx.jface.text.ITextPresentationListener; // packageimport | |
| 97 import dwtx.jface.text.Region; // packageimport | |
| 98 import dwtx.jface.text.ITextViewer; // packageimport | |
| 99 import dwtx.jface.text.IDocumentInformationMapping; // packageimport | |
| 100 import dwtx.jface.text.MarginPainter; // packageimport | |
| 101 import dwtx.jface.text.IPaintPositionManager; // packageimport | |
| 102 import dwtx.jface.text.TextPresentation; // packageimport | |
| 103 import dwtx.jface.text.IFindReplaceTargetExtension; // packageimport | |
| 104 import dwtx.jface.text.ISlaveDocumentManagerExtension; // packageimport | |
| 105 import dwtx.jface.text.ISelectionValidator; // packageimport | |
| 106 import dwtx.jface.text.IDocumentExtension; // packageimport | |
| 107 import dwtx.jface.text.PropagatingFontFieldEditor; // packageimport | |
| 108 import dwtx.jface.text.ConfigurableLineTracker; // packageimport | |
| 109 import dwtx.jface.text.SlaveDocumentEvent; // packageimport | |
| 110 import dwtx.jface.text.IDocumentListener; // packageimport | |
| 111 import dwtx.jface.text.PaintManager; // packageimport | |
| 112 import dwtx.jface.text.IFindReplaceTargetExtension3; // packageimport | |
| 113 import dwtx.jface.text.ITextDoubleClickStrategy; // packageimport | |
| 114 import dwtx.jface.text.IDocumentExtension3; // packageimport | |
| 115 import dwtx.jface.text.Position; // packageimport | |
| 116 import dwtx.jface.text.TextMessages; // packageimport | |
| 117 import dwtx.jface.text.CopyOnWriteTextStore; // packageimport | |
| 118 import dwtx.jface.text.WhitespaceCharacterPainter; // packageimport | |
| 119 import dwtx.jface.text.IPositionUpdater; // packageimport | |
| 120 import dwtx.jface.text.DefaultTextDoubleClickStrategy; // packageimport | |
| 121 import dwtx.jface.text.ListLineTracker; // packageimport | |
| 122 import dwtx.jface.text.ITextInputListener; // packageimport | |
| 123 import dwtx.jface.text.BadPositionCategoryException; // packageimport | |
| 124 import dwtx.jface.text.IWidgetTokenKeeperExtension; // packageimport | |
| 125 import dwtx.jface.text.IInputChangedListener; // packageimport | |
| 126 import dwtx.jface.text.ITextOperationTarget; // packageimport | |
| 127 import dwtx.jface.text.IDocumentInformationMappingExtension2; // packageimport | |
| 128 import dwtx.jface.text.ITextViewerExtension7; // packageimport | |
| 129 import dwtx.jface.text.IInformationControlExtension5; // packageimport | |
| 130 import dwtx.jface.text.IDocumentRewriteSessionListener; // packageimport | |
| 131 import dwtx.jface.text.JFaceTextUtil; // packageimport | |
| 132 import dwtx.jface.text.AbstractReusableInformationControlCreator; // packageimport | |
| 133 import dwtx.jface.text.TabsToSpacesConverter; // packageimport | |
| 134 import dwtx.jface.text.CursorLinePainter; // packageimport | |
| 135 import dwtx.jface.text.ITextHoverExtension; // packageimport | |
| 136 import dwtx.jface.text.IEventConsumer; // packageimport | |
| 137 import dwtx.jface.text.IDocument; // packageimport | |
| 138 import dwtx.jface.text.IWidgetTokenKeeper; // packageimport | |
| 139 import dwtx.jface.text.DocumentCommand; // packageimport | |
| 140 import dwtx.jface.text.TypedPosition; // packageimport | |
| 141 import dwtx.jface.text.IEditingSupportRegistry; // packageimport | |
| 142 import dwtx.jface.text.IDocumentPartitionerExtension; // packageimport | |
| 143 import dwtx.jface.text.AbstractHoverInformationControlManager; // packageimport | |
| 144 import dwtx.jface.text.IEditingSupport; // packageimport | |
| 145 import dwtx.jface.text.IMarkSelection; // packageimport | |
| 146 import dwtx.jface.text.ISlaveDocumentManager; // packageimport | |
| 147 import dwtx.jface.text.DocumentEvent; // packageimport | |
| 148 import dwtx.jface.text.DocumentPartitioningChangedEvent; // packageimport | |
| 149 import dwtx.jface.text.ITextStore; // packageimport | |
| 150 import dwtx.jface.text.JFaceTextMessages; // packageimport | |
| 151 import dwtx.jface.text.DocumentRewriteSessionEvent; // packageimport | |
| 152 import dwtx.jface.text.SequentialRewriteTextStore; // packageimport | |
| 153 import dwtx.jface.text.DocumentRewriteSessionType; // packageimport | |
| 154 import dwtx.jface.text.TextAttribute; // packageimport | |
| 155 import dwtx.jface.text.ITextViewerExtension4; // packageimport | |
| 156 import dwtx.jface.text.ITypedRegion; // packageimport | |
| 157 | |
| 129 | 158 import dwt.dwthelper.utils; |
| 159 | |
| 160 | |
|
153
f70d9508c95c
Fix java Collection imports
Frank Benoit <benoit@tionex.de>
parents:
151
diff
changeset
|
161 import dwtx.dwtxhelper.Collection; |
|
f70d9508c95c
Fix java Collection imports
Frank Benoit <benoit@tionex.de>
parents:
151
diff
changeset
|
162 |
| 129 | 163 |
| 164 import dwt.DWT; | |
| 165 import dwt.custom.StyledText; | |
| 166 import dwt.events.KeyEvent; | |
| 167 import dwt.events.KeyListener; | |
| 168 import dwt.events.MouseEvent; | |
| 169 import dwt.events.MouseListener; | |
| 170 import dwt.widgets.Display; | |
| 171 import dwt.widgets.Shell; | |
| 172 import dwtx.core.commands.ExecutionException; | |
| 173 import dwtx.core.commands.operations.AbstractOperation; | |
| 174 import dwtx.core.commands.operations.IOperationHistory; | |
| 175 import dwtx.core.commands.operations.IOperationHistoryListener; | |
| 176 import dwtx.core.commands.operations.IUndoContext; | |
| 177 import dwtx.core.commands.operations.IUndoableOperation; | |
| 178 import dwtx.core.commands.operations.ObjectUndoContext; | |
| 179 import dwtx.core.commands.operations.OperationHistoryEvent; | |
| 180 import dwtx.core.commands.operations.OperationHistoryFactory; | |
| 181 import dwtx.core.runtime.IAdaptable; | |
| 182 import dwtx.core.runtime.IProgressMonitor; | |
| 183 import dwtx.core.runtime.IStatus; | |
| 184 import dwtx.core.runtime.Status; | |
| 185 import dwtx.jface.dialogs.MessageDialog; | |
| 186 | |
| 187 | |
| 188 /** | |
| 189 * Standard implementation of {@link dwtx.jface.text.IUndoManager}. | |
| 190 * <p> | |
| 191 * It registers with the connected text viewer as text input listener and | |
| 192 * document listener and logs all changes. It also monitors mouse and keyboard | |
| 193 * activities in order to partition the stream of text changes into undo-able | |
| 194 * edit commands. | |
| 195 * </p> | |
| 196 * <p> | |
| 197 * Since 3.1 this undo manager is a facade to the global operation history. | |
| 198 * </p> | |
| 199 * <p> | |
| 200 * The usage of {@link dwtx.core.runtime.IAdaptable} in the JFace | |
| 201 * layer has been approved by Platform UI, see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=87669#c9 | |
| 202 * </p> | |
| 203 * <p> | |
| 204 * This class is not intended to be subclassed. | |
| 205 * </p> | |
| 206 * | |
| 207 * @see dwtx.jface.text.ITextViewer | |
| 208 * @see dwtx.jface.text.ITextInputListener | |
| 209 * @see dwtx.jface.text.IDocumentListener | |
| 210 * @see dwtx.core.commands.operations.IUndoableOperation | |
| 211 * @see dwtx.core.commands.operations.IOperationHistory | |
| 212 * @see MouseListener | |
| 213 * @see KeyListener | |
| 214 * @deprecated As of 3.2, replaced by {@link TextViewerUndoManager} | |
| 215 * @noextend This class is not intended to be subclassed by clients. | |
| 216 */ | |
| 217 public class DefaultUndoManager : IUndoManager, IUndoManagerExtension { | |
| 218 | |
| 219 /** | |
| 220 * Represents an undo-able edit command. | |
| 221 * <p> | |
| 222 * Since 3.1 this implements the interface for IUndoableOperation. | |
| 223 * </p> | |
| 224 */ | |
| 225 class TextCommand : AbstractOperation { | |
| 226 | |
| 227 /** The start index of the replaced text. */ | |
| 228 protected int fStart= -1; | |
| 229 /** The end index of the replaced text. */ | |
| 230 protected int fEnd= -1; | |
| 231 /** The newly inserted text. */ | |
| 232 protected String fText; | |
| 233 /** The replaced text. */ | |
| 234 protected String fPreservedText; | |
| 235 | |
| 236 /** The undo modification stamp. */ | |
| 237 protected long fUndoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 238 /** The redo modification stamp. */ | |
| 239 protected long fRedoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 240 | |
| 241 /** | |
| 242 * Creates a new text command. | |
| 243 * | |
| 244 * @param context the undo context for this command | |
| 245 * @since 3.1 | |
| 246 */ | |
|
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
247 this(IUndoContext context) { |
| 129 | 248 super(JFaceTextMessages.getString("DefaultUndoManager.operationLabel")); //$NON-NLS-1$ |
| 249 addContext(context); | |
| 250 } | |
| 251 | |
| 252 /** | |
| 253 * Re-initializes this text command. | |
| 254 */ | |
| 255 protected void reinitialize() { | |
| 256 fStart= fEnd= -1; | |
| 257 fText= fPreservedText= null; | |
| 258 fUndoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 259 fRedoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 260 } | |
| 261 | |
| 262 /** | |
| 263 * Sets the start and the end index of this command. | |
| 264 * | |
| 265 * @param start the start index | |
| 266 * @param end the end index | |
| 267 */ | |
| 268 protected void set(int start, int end) { | |
| 269 fStart= start; | |
| 270 fEnd= end; | |
| 271 fText= null; | |
| 272 fPreservedText= null; | |
| 273 } | |
| 274 | |
| 275 /* | |
| 276 * @see dwtx.core.commands.operations.IUndoableOperation#dispose() | |
| 277 * @since 3.1 | |
| 278 */ | |
| 279 public void dispose() { | |
| 280 reinitialize(); | |
| 281 } | |
| 282 | |
| 283 /** | |
| 284 * Undo the change described by this command. | |
| 285 * | |
| 286 * @since 2.0 | |
| 287 */ | |
| 288 protected void undoTextChange() { | |
| 289 try { | |
| 290 IDocument document= fTextViewer.getDocument(); | |
| 138 | 291 if ( cast(IDocumentExtension4)document ) |
| 134 | 292 (cast(IDocumentExtension4)document).replace(fStart, fText.length(), fPreservedText, fUndoModificationStamp); |
| 129 | 293 else |
| 294 document.replace(fStart, fText.length(), fPreservedText); | |
| 295 } catch (BadLocationException x) { | |
| 296 } | |
| 297 } | |
| 298 | |
| 299 /* | |
| 300 * @see dwtx.core.commands.operations.IUndoableOperation#canUndo() | |
| 301 * @since 3.1 | |
| 302 */ | |
| 303 public bool canUndo() { | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
304 |
| 129 | 305 if (isConnected() && isValid()) { |
| 306 IDocument doc= fTextViewer.getDocument(); | |
| 138 | 307 if ( cast(IDocumentExtension4)doc ) { |
| 134 | 308 long docStamp= (cast(IDocumentExtension4)doc).getModificationStamp(); |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
309 |
| 129 | 310 // Normal case: an undo is valid if its redo will restore document |
| 311 // to its current modification stamp | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
312 bool canUndo= docStamp is IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP || |
| 129 | 313 docStamp is getRedoModificationStamp(); |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
314 |
|
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
315 /* Special case to check if the answer is false. |
| 129 | 316 * If the last document change was empty, then the document's |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
317 * modification stamp was incremented but nothing was committed. |
| 129 | 318 * The operation being queried has an older stamp. In this case only, |
| 319 * the comparison is different. A sequence of document changes that | |
| 320 * include an empty change is handled correctly when a valid commit | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
321 * follows the empty change, but when #canUndo() is queried just after |
| 129 | 322 * an empty change, we must special case the check. The check is very |
| 323 * specific to prevent false positives. | |
| 324 * see https://bugs.eclipse.org/bugs/show_bug.cgi?id=98245 | |
| 325 */ | |
| 326 if (!canUndo && | |
| 327 this is fHistory.getUndoOperation(fUndoContext) && // this is the latest operation | |
| 328 this !is fCurrent && // there is a more current operation not on the stack | |
| 329 !fCurrent.isValid() && // the current operation is not a valid document modification | |
| 330 fCurrent.fUndoModificationStamp !is // the invalid current operation has a document stamp | |
| 331 IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP) { | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
332 canUndo= fCurrent.fRedoModificationStamp is docStamp; |
| 129 | 333 } |
| 334 /* | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
335 * When the composite is the current command, it may hold the timestamp |
|
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
336 * of a no-op change. We check this here rather than in an override of |
| 129 | 337 * canUndo() in CompoundTextCommand simply to keep all the special case checks |
| 338 * in one place. | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
339 */ |
| 129 | 340 if (!canUndo && |
| 341 this is fHistory.getUndoOperation(fUndoContext) && // this is the latest operation | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
342 null !is cast(CompoundTextCommand)this && |
| 129 | 343 this is fCurrent && // this is the current operation |
| 344 this.fStart is -1 && // the current operation text is not valid | |
| 345 fCurrent.fRedoModificationStamp !is IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP) { // but it has a redo stamp | |
| 346 canUndo= fCurrent.fRedoModificationStamp is docStamp; | |
| 347 } | |
| 348 | |
| 349 } | |
| 350 // if there is no timestamp to check, simply return true per the 3.0.1 behavior | |
| 351 return true; | |
| 352 } | |
| 353 return false; | |
| 354 } | |
| 355 | |
| 356 /* | |
| 357 * @see dwtx.core.commands.operations.IUndoableOperation#canRedo() | |
| 358 * @since 3.1 | |
| 359 */ | |
| 360 public bool canRedo() { | |
| 361 if (isConnected() && isValid()) { | |
| 362 IDocument doc= fTextViewer.getDocument(); | |
| 138 | 363 if ( cast(IDocumentExtension4)doc ) { |
| 134 | 364 long docStamp= (cast(IDocumentExtension4)doc).getModificationStamp(); |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
365 return docStamp is IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP || |
| 129 | 366 docStamp is getUndoModificationStamp(); |
| 367 } | |
| 368 // if there is no timestamp to check, simply return true per the 3.0.1 behavior | |
| 369 return true; | |
| 370 } | |
| 371 return false; | |
| 372 } | |
| 373 | |
| 374 /* | |
| 375 * @see dwtx.core.commands.operations.IUndoableOperation#canExecute() | |
| 376 * @since 3.1 | |
| 377 */ | |
| 378 public bool canExecute() { | |
| 379 return isConnected(); | |
| 380 } | |
| 381 | |
| 382 /* | |
| 383 * @see dwtx.core.commands.operations.IUndoableOperation#execute(dwtx.core.runtime.IProgressMonitor, dwtx.core.runtime.IAdaptable) | |
| 384 * @since 3.1 | |
| 385 */ | |
| 386 public IStatus execute(IProgressMonitor monitor, IAdaptable uiInfo) { | |
| 387 // Text commands execute as they are typed, so executing one has no effect. | |
| 388 return Status.OK_STATUS; | |
| 389 } | |
| 390 | |
| 391 /* | |
| 392 * Undo the change described by this command. Also selects and | |
| 393 * reveals the change. | |
| 394 */ | |
| 395 | |
| 396 /** | |
| 397 * Undo the change described by this command. Also selects and | |
| 398 * reveals the change. | |
| 399 * | |
| 400 * @param monitor the progress monitor to use if necessary | |
| 401 * @param uiInfo an adaptable that can provide UI info if needed | |
| 402 * @return the status | |
| 403 */ | |
| 404 public IStatus undo(IProgressMonitor monitor, IAdaptable uiInfo) { | |
| 405 if (isValid()) { | |
| 406 undoTextChange(); | |
| 407 selectAndReveal(fStart, fPreservedText is null ? 0 : fPreservedText.length()); | |
| 408 resetProcessChangeSate(); | |
| 409 return Status.OK_STATUS; | |
| 410 } | |
| 411 return IOperationHistory.OPERATION_INVALID_STATUS; | |
| 412 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
413 |
| 129 | 414 /** |
| 415 * Re-applies the change described by this command. | |
| 416 * | |
| 417 * @since 2.0 | |
| 418 */ | |
| 419 protected void redoTextChange() { | |
| 420 try { | |
| 421 IDocument document= fTextViewer.getDocument(); | |
| 138 | 422 if ( cast(IDocumentExtension4)document ) |
| 134 | 423 (cast(IDocumentExtension4)document).replace(fStart, fEnd - fStart, fText, fRedoModificationStamp); |
| 129 | 424 else |
| 425 fTextViewer.getDocument().replace(fStart, fEnd - fStart, fText); | |
| 426 } catch (BadLocationException x) { | |
| 427 } | |
| 428 } | |
| 429 | |
| 430 /** | |
| 431 * Re-applies the change described by this command that previously been | |
| 432 * rolled back. Also selects and reveals the change. | |
| 433 * | |
| 434 * @param monitor the progress monitor to use if necessary | |
| 435 * @param uiInfo an adaptable that can provide UI info if needed | |
| 436 * @return the status | |
| 437 */ | |
| 438 public IStatus redo(IProgressMonitor monitor, IAdaptable uiInfo) { | |
| 439 if (isValid()) { | |
| 440 redoTextChange(); | |
| 441 resetProcessChangeSate(); | |
| 442 selectAndReveal(fStart, fText is null ? 0 : fText.length()); | |
| 443 return Status.OK_STATUS; | |
| 444 } | |
| 445 return IOperationHistory.OPERATION_INVALID_STATUS; | |
| 446 } | |
| 447 | |
| 448 /** | |
| 449 * Update the command in response to a commit. | |
| 450 * | |
| 451 * @since 3.1 | |
| 452 */ | |
| 453 | |
| 454 protected void updateCommand() { | |
| 455 fText= fTextBuffer.toString(); | |
| 456 fTextBuffer.setLength(0); | |
| 457 fPreservedText= fPreservedTextBuffer.toString(); | |
| 458 fPreservedTextBuffer.setLength(0); | |
| 459 } | |
| 460 | |
| 461 /** | |
| 462 * Creates a new uncommitted text command depending on whether | |
| 463 * a compound change is currently being executed. | |
| 464 * | |
| 465 * @return a new, uncommitted text command or a compound text command | |
| 466 */ | |
| 467 protected TextCommand createCurrent() { | |
| 468 return fFoldingIntoCompoundChange ? new CompoundTextCommand(fUndoContext) : new TextCommand(fUndoContext); | |
| 469 } | |
| 470 | |
| 471 /** | |
| 472 * Commits the current change into this command. | |
| 473 */ | |
| 474 protected void commit() { | |
| 475 if (fStart < 0) { | |
| 476 if (fFoldingIntoCompoundChange) { | |
| 477 fCurrent= createCurrent(); | |
| 478 } else { | |
| 479 reinitialize(); | |
| 480 } | |
| 481 } else { | |
| 482 updateCommand(); | |
| 483 fCurrent= createCurrent(); | |
| 484 } | |
| 485 resetProcessChangeSate(); | |
| 486 } | |
| 487 | |
| 488 /** | |
| 489 * Updates the text from the buffers without resetting | |
| 490 * the buffers or adding anything to the stack. | |
| 491 * | |
| 492 * @since 3.1 | |
| 493 */ | |
| 494 protected void pretendCommit() { | |
| 495 if (fStart > -1) { | |
| 496 fText= fTextBuffer.toString(); | |
| 497 fPreservedText= fPreservedTextBuffer.toString(); | |
| 498 } | |
| 499 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
500 |
| 129 | 501 /** |
| 502 * Attempt a commit of this command and answer true if a new | |
| 503 * fCurrent was created as a result of the commit. | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
504 * |
| 129 | 505 * @return true if the command was committed and created a |
| 506 * new fCurrent, false if not. | |
| 507 * @since 3.1 | |
| 508 */ | |
| 509 protected bool attemptCommit() { | |
| 510 pretendCommit(); | |
| 511 if (isValid()) { | |
| 137 | 512 this.outer.commit(); |
| 129 | 513 return true; |
| 514 } | |
| 515 return false; | |
| 516 } | |
| 517 | |
| 518 /** | |
| 519 * Checks whether this text command is valid for undo or redo. | |
| 520 * | |
| 521 * @return <code>true</code> if the command is valid for undo or redo | |
| 522 * @since 3.1 | |
| 523 */ | |
| 524 protected bool isValid() { | |
| 525 return fStart > -1 && | |
| 526 fEnd > -1 && | |
| 527 fText !is null; | |
| 528 } | |
| 529 | |
| 530 /* | |
| 531 * @see java.lang.Object#toString() | |
| 532 * @since 3.1 | |
| 533 */ | |
| 534 public String toString() { | |
| 535 String delimiter= ", "; //$NON-NLS-1$ | |
| 536 StringBuffer text= new StringBuffer(super.toString()); | |
| 537 text.append("\n"); //$NON-NLS-1$ | |
| 538 text.append(this.getClass().getName()); | |
| 539 text.append(" undo modification stamp: "); //$NON-NLS-1$ | |
| 540 text.append(fUndoModificationStamp); | |
| 541 text.append(" redo modification stamp: "); //$NON-NLS-1$ | |
| 542 text.append(fRedoModificationStamp); | |
| 543 text.append(" start: "); //$NON-NLS-1$ | |
| 544 text.append(fStart); | |
| 545 text.append(delimiter); | |
| 546 text.append("end: "); //$NON-NLS-1$ | |
| 547 text.append(fEnd); | |
| 548 text.append(delimiter); | |
| 549 text.append("text: '"); //$NON-NLS-1$ | |
| 550 text.append(fText); | |
| 551 text.append('\''); | |
| 552 text.append(delimiter); | |
| 553 text.append("preservedText: '"); //$NON-NLS-1$ | |
| 554 text.append(fPreservedText); | |
| 555 text.append('\''); | |
| 556 return text.toString(); | |
| 557 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
558 |
| 129 | 559 /** |
| 560 * Return the undo modification stamp | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
561 * |
| 129 | 562 * @return the undo modification stamp for this command |
| 563 * @since 3.1 | |
| 564 */ | |
| 565 protected long getUndoModificationStamp() { | |
| 566 return fUndoModificationStamp; | |
| 567 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
568 |
| 129 | 569 /** |
| 570 * Return the redo modification stamp | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
571 * |
| 129 | 572 * @return the redo modification stamp for this command |
| 573 * @since 3.1 | |
| 574 */ | |
| 575 protected long getRedoModificationStamp() { | |
| 576 return fRedoModificationStamp; | |
| 577 } | |
| 578 } | |
| 579 | |
| 580 /** | |
| 581 * Represents an undo-able edit command consisting of several | |
| 582 * individual edit commands. | |
| 583 */ | |
| 584 class CompoundTextCommand : TextCommand { | |
| 585 | |
| 586 /** The list of individual commands */ | |
| 587 private List fCommands= new ArrayList(); | |
| 588 | |
| 589 /** | |
| 590 * Creates a new compound text command. | |
| 591 * | |
| 592 * @param context the undo context for this command | |
| 593 * @since 3.1 | |
| 594 */ | |
|
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
595 this(IUndoContext context) { |
| 129 | 596 super(context); |
| 597 } | |
| 598 | |
| 599 /** | |
| 600 * Adds a new individual command to this compound command. | |
| 601 * | |
| 602 * @param command the command to be added | |
| 603 */ | |
| 604 protected void add(TextCommand command) { | |
| 605 fCommands.add(command); | |
| 606 } | |
| 607 | |
| 608 /* | |
| 609 * @see dwtx.jface.text.DefaultUndoManager.TextCommand#undo() | |
| 610 */ | |
| 611 public IStatus undo(IProgressMonitor monitor, IAdaptable uiInfo) { | |
| 612 resetProcessChangeSate(); | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
613 |
| 129 | 614 int size= fCommands.size(); |
| 615 if (size > 0) { | |
| 616 | |
| 617 TextCommand c; | |
| 618 | |
| 619 for (int i= size -1; i > 0; --i) { | |
| 134 | 620 c= cast(TextCommand) fCommands.get(i); |
| 129 | 621 c.undoTextChange(); |
| 622 } | |
| 623 | |
| 134 | 624 c= cast(TextCommand) fCommands.get(0); |
| 129 | 625 c.undo(monitor, uiInfo); |
| 626 } | |
| 627 | |
| 628 return Status.OK_STATUS; | |
| 629 } | |
| 630 | |
| 631 /* | |
| 632 * @see dwtx.jface.text.DefaultUndoManager.TextCommand#redo() | |
| 633 */ | |
| 634 public IStatus redo(IProgressMonitor monitor, IAdaptable uiInfo) { | |
| 635 resetProcessChangeSate(); | |
| 636 | |
| 637 int size= fCommands.size(); | |
| 638 if (size > 0) { | |
| 639 | |
| 640 TextCommand c; | |
| 641 | |
| 642 for (int i= 0; i < size -1; ++i) { | |
| 134 | 643 c= cast(TextCommand) fCommands.get(i); |
| 129 | 644 c.redoTextChange(); |
| 645 } | |
| 646 | |
| 134 | 647 c= cast(TextCommand) fCommands.get(size -1); |
| 129 | 648 c.redo(monitor, uiInfo); |
| 649 } | |
| 650 return Status.OK_STATUS; | |
| 651 } | |
| 652 | |
| 653 /* | |
| 654 * @see TextCommand#updateCommand | |
| 655 | |
| 656 */ | |
| 657 | |
| 658 protected void updateCommand() { | |
| 659 // first gather the data from the buffers | |
| 660 super.updateCommand(); | |
| 661 | |
| 662 // the result of the command update is stored as a child command | |
| 663 TextCommand c= new TextCommand(fUndoContext); | |
| 664 c.fStart= fStart; | |
| 665 c.fEnd= fEnd; | |
| 666 c.fText= fText; | |
| 667 c.fPreservedText= fPreservedText; | |
| 668 c.fUndoModificationStamp= fUndoModificationStamp; | |
| 669 c.fRedoModificationStamp= fRedoModificationStamp; | |
| 670 add(c); | |
| 671 | |
| 672 // clear out all indexes now that the child is added | |
| 673 reinitialize(); | |
| 674 } | |
| 675 | |
| 676 /* | |
| 677 * @see TextCommand#createCurrent | |
| 678 */ | |
| 679 protected TextCommand createCurrent() { | |
| 680 | |
| 681 if (!fFoldingIntoCompoundChange) | |
| 682 return new TextCommand(fUndoContext); | |
| 683 | |
| 684 reinitialize(); | |
| 685 return this; | |
| 686 } | |
| 687 | |
| 688 /* | |
| 689 * @see dwtx.jface.text.DefaultUndoManager.TextCommand#commit() | |
| 690 */ | |
| 691 protected void commit() { | |
| 692 // if there is pending data, update the command | |
| 693 if (fStart > -1) | |
| 694 updateCommand(); | |
| 695 fCurrent= createCurrent(); | |
| 696 resetProcessChangeSate(); | |
| 697 } | |
| 698 | |
| 699 /** | |
| 700 * Checks whether the command is valid for undo or redo. | |
| 701 * | |
| 702 * @return true if the command is valid. | |
| 703 * @since 3.1 | |
| 704 */ | |
| 705 protected bool isValid() { | |
| 706 if (isConnected()) | |
| 707 return (fStart > -1 || fCommands.size() > 0); | |
| 708 return false; | |
| 709 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
710 |
| 129 | 711 /** |
| 712 * Returns the undo modification stamp. | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
713 * |
| 129 | 714 * @return the undo modification stamp |
| 715 * @since 3.1 | |
| 716 */ | |
| 717 protected long getUndoModificationStamp() { | |
| 718 if (fStart > -1) | |
| 719 return super.getUndoModificationStamp(); | |
| 720 else if (fCommands.size() > 0) | |
| 134 | 721 return (cast(TextCommand)fCommands.get(0)).getUndoModificationStamp(); |
| 129 | 722 |
| 723 return fUndoModificationStamp; | |
| 724 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
725 |
| 129 | 726 /** |
| 727 * Returns the redo modification stamp. | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
728 * |
| 129 | 729 * @return the redo modification stamp |
| 730 * @since 3.1 | |
| 731 */ | |
| 732 protected long getRedoModificationStamp() { | |
| 733 if (fStart > -1) | |
| 734 return super.getRedoModificationStamp(); | |
| 735 else if (fCommands.size() > 0) | |
| 134 | 736 return (cast(TextCommand)fCommands.get(fCommands.size()-1)).getRedoModificationStamp(); |
| 129 | 737 |
| 738 return fRedoModificationStamp; | |
| 739 } | |
| 740 } | |
| 741 | |
| 742 /** | |
| 743 * Internal listener to mouse and key events. | |
| 744 */ | |
| 745 class KeyAndMouseListener : MouseListener, KeyListener { | |
| 746 | |
| 747 /* | |
| 748 * @see MouseListener#mouseDoubleClick | |
| 749 */ | |
| 750 public void mouseDoubleClick(MouseEvent e) { | |
| 751 } | |
| 752 | |
| 753 /* | |
| 754 * If the right mouse button is pressed, the current editing command is closed | |
| 755 * @see MouseListener#mouseDown | |
| 756 */ | |
| 757 public void mouseDown(MouseEvent e) { | |
| 758 if (e.button is 1) | |
| 759 commit(); | |
| 760 } | |
| 761 | |
| 762 /* | |
| 763 * @see MouseListener#mouseUp | |
| 764 */ | |
| 765 public void mouseUp(MouseEvent e) { | |
| 766 } | |
| 767 | |
| 768 /* | |
| 769 * @see KeyListener#keyPressed | |
| 770 */ | |
| 771 public void keyReleased(KeyEvent e) { | |
| 772 } | |
| 773 | |
| 774 /* | |
| 775 * On cursor keys, the current editing command is closed | |
| 776 * @see KeyListener#keyPressed | |
| 777 */ | |
| 778 public void keyPressed(KeyEvent e) { | |
| 779 switch (e.keyCode) { | |
| 780 case DWT.ARROW_UP: | |
| 781 case DWT.ARROW_DOWN: | |
| 782 case DWT.ARROW_LEFT: | |
| 783 case DWT.ARROW_RIGHT: | |
| 784 commit(); | |
| 785 break; | |
| 786 } | |
| 787 } | |
| 788 } | |
| 789 | |
| 790 /** | |
| 791 * Internal listener to document changes. | |
| 792 */ | |
| 793 class DocumentListener : IDocumentListener { | |
| 794 | |
| 795 private String fReplacedText; | |
| 796 | |
| 797 /* | |
| 798 * @see dwtx.jface.text.IDocumentListener#documentAboutToBeChanged(dwtx.jface.text.DocumentEvent) | |
| 799 */ | |
| 800 public void documentAboutToBeChanged(DocumentEvent event) { | |
| 801 try { | |
| 802 fReplacedText= event.getDocument().get(event.getOffset(), event.getLength()); | |
| 803 fPreservedUndoModificationStamp= event.getModificationStamp(); | |
| 804 } catch (BadLocationException x) { | |
| 805 fReplacedText= null; | |
| 806 } | |
| 807 } | |
| 808 | |
| 809 /* | |
| 810 * @see dwtx.jface.text.IDocumentListener#documentChanged(dwtx.jface.text.DocumentEvent) | |
| 811 */ | |
| 812 public void documentChanged(DocumentEvent event) { | |
| 813 fPreservedRedoModificationStamp= event.getModificationStamp(); | |
| 814 | |
| 815 // record the current valid state for the top operation in case it remains the | |
| 816 // top operation but changes state. | |
| 817 IUndoableOperation op= fHistory.getUndoOperation(fUndoContext); | |
| 818 bool wasValid= false; | |
| 819 if (op !is null) | |
| 820 wasValid= op.canUndo(); | |
| 821 // Process the change, providing the before and after timestamps | |
| 822 processChange(event.getOffset(), event.getOffset() + event.getLength(), event.getText(), fReplacedText, fPreservedUndoModificationStamp, fPreservedRedoModificationStamp); | |
| 823 | |
| 824 // now update fCurrent with the latest buffers from the document change. | |
| 825 fCurrent.pretendCommit(); | |
| 826 | |
| 827 if (op is fCurrent) { | |
| 828 // if the document change did not cause a new fCurrent to be created, then we should | |
| 829 // notify the history that the current operation changed if its validity has changed. | |
| 830 if (wasValid !is fCurrent.isValid()) | |
| 831 fHistory.operationChanged(op); | |
| 832 } | |
| 833 else { | |
| 834 // if the change created a new fCurrent that we did not yet add to the | |
| 835 // stack, do so if it's valid and we are not in the middle of a compound change. | |
| 836 if (fCurrent !is fLastAddedCommand && fCurrent.isValid()) { | |
| 837 addToCommandStack(fCurrent); | |
| 838 } | |
| 839 } | |
| 840 } | |
| 841 } | |
| 842 | |
| 843 /** | |
| 844 * Internal text input listener. | |
| 845 */ | |
| 846 class TextInputListener : ITextInputListener { | |
| 847 | |
| 848 /* | |
| 849 * @see dwtx.jface.text.ITextInputListener#inputDocumentAboutToBeChanged(dwtx.jface.text.IDocument, dwtx.jface.text.IDocument) | |
| 850 */ | |
| 851 public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput) { | |
| 852 if (oldInput !is null && fDocumentListener !is null) { | |
| 853 oldInput.removeDocumentListener(fDocumentListener); | |
| 854 commit(); | |
| 855 } | |
| 856 } | |
| 857 | |
| 858 /* | |
| 859 * @see dwtx.jface.text.ITextInputListener#inputDocumentChanged(dwtx.jface.text.IDocument, dwtx.jface.text.IDocument) | |
| 860 */ | |
| 861 public void inputDocumentChanged(IDocument oldInput, IDocument newInput) { | |
| 862 if (newInput !is null) { | |
| 863 if (fDocumentListener is null) | |
| 864 fDocumentListener= new DocumentListener(); | |
| 865 newInput.addDocumentListener(fDocumentListener); | |
| 866 } | |
| 867 } | |
| 868 | |
| 869 } | |
| 870 | |
| 871 /* | |
| 872 * @see IOperationHistoryListener | |
| 873 * @since 3.1 | |
| 874 */ | |
| 875 class HistoryListener : IOperationHistoryListener { | |
| 876 private IUndoableOperation fOperation; | |
| 877 | |
| 156 | 878 public void historyNotification(OperationHistoryEvent event) { |
| 879 int type= event.getEventType(); | |
| 129 | 880 switch (type) { |
| 881 case OperationHistoryEvent.ABOUT_TO_UNDO: | |
| 882 case OperationHistoryEvent.ABOUT_TO_REDO: | |
| 883 // if this is one of our operations | |
| 884 if (event.getOperation().hasContext(fUndoContext)) { | |
| 156 | 885 fTextViewer.getTextWidget().getDisplay().syncExec(dgRunnable((Event event_, int type_ ) { |
| 886 // if we are undoing/redoing a command we generated, then ignore | |
| 887 // the document changes associated with this undo or redo. | |
| 888 if (cast(TextCommand)event_.getOperation() ) { | |
| 889 if ( cast(TextViewer)fTextViewer ) | |
| 890 (cast(TextViewer)fTextViewer).ignoreAutoEditStrategies(true); | |
| 891 listenToTextChanges(false); | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
892 |
| 156 | 893 // in the undo case only, make sure compounds are closed |
| 894 if (type_ is OperationHistoryEvent.ABOUT_TO_UNDO) { | |
| 895 if (fFoldingIntoCompoundChange) { | |
| 896 endCompoundChange(); | |
| 129 | 897 } |
| 898 } | |
| 156 | 899 } else { |
| 900 // the undo or redo has our context, but it is not one of | |
| 901 // our commands. We will listen to the changes, but will | |
| 902 // reset the state that tracks the undo/redo history. | |
| 903 commit(); | |
| 904 fLastAddedCommand= null; | |
| 129 | 905 } |
| 156 | 906 }, event, type )); |
| 129 | 907 fOperation= event.getOperation(); |
| 908 } | |
| 909 break; | |
| 910 case OperationHistoryEvent.UNDONE: | |
| 911 case OperationHistoryEvent.REDONE: | |
| 912 case OperationHistoryEvent.OPERATION_NOT_OK: | |
| 913 if (event.getOperation() is fOperation) { | |
| 135 | 914 fTextViewer.getTextWidget().getDisplay().syncExec(new class() Runnable { |
| 129 | 915 public void run() { |
| 916 listenToTextChanges(true); | |
| 917 fOperation= null; | |
| 138 | 918 if ( cast(TextViewer)fTextViewer ) |
| 134 | 919 (cast(TextViewer)fTextViewer).ignoreAutoEditStrategies(false); |
| 129 | 920 } |
| 921 }); | |
| 922 } | |
| 923 break; | |
| 924 } | |
| 925 } | |
| 926 | |
| 927 } | |
| 928 | |
| 929 /** Text buffer to collect text which is inserted into the viewer */ | |
| 930 private StringBuffer fTextBuffer= new StringBuffer(); | |
| 931 /** Text buffer to collect viewer content which has been replaced */ | |
| 932 private StringBuffer fPreservedTextBuffer= new StringBuffer(); | |
| 933 /** The document modification stamp for undo. */ | |
| 934 protected long fPreservedUndoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 935 /** The document modification stamp for redo. */ | |
| 936 protected long fPreservedRedoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 937 /** The internal key and mouse event listener */ | |
| 938 private KeyAndMouseListener fKeyAndMouseListener; | |
| 939 /** The internal document listener */ | |
| 940 private DocumentListener fDocumentListener; | |
| 941 /** The internal text input listener */ | |
| 942 private TextInputListener fTextInputListener; | |
| 943 | |
| 944 | |
| 945 /** Indicates inserting state */ | |
| 946 private bool fInserting= false; | |
| 947 /** Indicates overwriting state */ | |
| 948 private bool fOverwriting= false; | |
| 949 /** Indicates whether the current change belongs to a compound change */ | |
| 950 private bool fFoldingIntoCompoundChange= false; | |
| 951 | |
| 952 /** The text viewer the undo manager is connected to */ | |
| 953 private ITextViewer fTextViewer; | |
| 954 | |
| 955 /** Supported undo level */ | |
| 956 private int fUndoLevel; | |
| 957 /** The currently constructed edit command */ | |
| 958 private TextCommand fCurrent; | |
| 959 /** The last delete edit command */ | |
| 960 private TextCommand fPreviousDelete; | |
| 961 | |
| 962 /** | |
| 963 * The undo context. | |
| 964 * @since 3.1 | |
| 965 */ | |
| 966 private IOperationHistory fHistory; | |
| 967 /** | |
| 968 * The operation history. | |
| 969 * @since 3.1 | |
| 970 */ | |
| 971 private IUndoContext fUndoContext; | |
| 972 /** | |
| 973 * The operation history listener used for managing undo and redo before | |
| 974 * and after the individual commands are performed. | |
| 975 * @since 3.1 | |
| 976 */ | |
| 977 private IOperationHistoryListener fHistoryListener= new HistoryListener(); | |
| 978 | |
| 979 /** | |
| 980 * The command last added to the operation history. This must be tracked | |
| 981 * internally instead of asking the history, since outside parties may be placing | |
| 982 * items on our undo/redo history. | |
| 983 */ | |
| 984 private TextCommand fLastAddedCommand= null; | |
| 985 | |
| 986 /** | |
| 987 * Creates a new undo manager who remembers the specified number of edit commands. | |
| 988 * | |
| 989 * @param undoLevel the length of this manager's history | |
| 990 */ | |
|
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
991 public this(int undoLevel) { |
| 129 | 992 fHistory= OperationHistoryFactory.getOperationHistory(); |
| 993 setMaximalUndoLevel(undoLevel); | |
| 994 } | |
| 995 | |
| 996 /** | |
| 997 * Returns whether this undo manager is connected to a text viewer. | |
| 998 * | |
| 999 * @return <code>true</code> if connected, <code>false</code> otherwise | |
| 1000 * @since 3.1 | |
| 1001 */ | |
| 1002 private bool isConnected() { | |
| 1003 return fTextViewer !is null; | |
| 1004 } | |
| 1005 | |
| 1006 /* | |
| 1007 * @see IUndoManager#beginCompoundChange | |
| 1008 */ | |
| 1009 public void beginCompoundChange() { | |
| 1010 if (isConnected()) { | |
| 1011 fFoldingIntoCompoundChange= true; | |
| 1012 commit(); | |
| 1013 } | |
| 1014 } | |
| 1015 | |
| 1016 | |
| 1017 /* | |
| 1018 * @see IUndoManager#endCompoundChange | |
| 1019 */ | |
| 1020 public void endCompoundChange() { | |
| 1021 if (isConnected()) { | |
| 1022 fFoldingIntoCompoundChange= false; | |
| 1023 commit(); | |
| 1024 } | |
| 1025 } | |
| 1026 | |
| 1027 /** | |
| 1028 * Registers all necessary listeners with the text viewer. | |
| 1029 */ | |
| 1030 private void addListeners() { | |
| 1031 StyledText text= fTextViewer.getTextWidget(); | |
| 1032 if (text !is null) { | |
| 1033 fKeyAndMouseListener= new KeyAndMouseListener(); | |
| 1034 text.addMouseListener(fKeyAndMouseListener); | |
| 1035 text.addKeyListener(fKeyAndMouseListener); | |
| 1036 fTextInputListener= new TextInputListener(); | |
| 1037 fTextViewer.addTextInputListener(fTextInputListener); | |
| 1038 fHistory.addOperationHistoryListener(fHistoryListener); | |
| 1039 listenToTextChanges(true); | |
| 1040 } | |
| 1041 } | |
| 1042 | |
| 1043 /** | |
| 1044 * Unregister all previously installed listeners from the text viewer. | |
| 1045 */ | |
| 1046 private void removeListeners() { | |
| 1047 StyledText text= fTextViewer.getTextWidget(); | |
| 1048 if (text !is null) { | |
| 1049 if (fKeyAndMouseListener !is null) { | |
| 1050 text.removeMouseListener(fKeyAndMouseListener); | |
| 1051 text.removeKeyListener(fKeyAndMouseListener); | |
| 1052 fKeyAndMouseListener= null; | |
| 1053 } | |
| 1054 if (fTextInputListener !is null) { | |
| 1055 fTextViewer.removeTextInputListener(fTextInputListener); | |
| 1056 fTextInputListener= null; | |
| 1057 } | |
| 1058 listenToTextChanges(false); | |
| 1059 fHistory.removeOperationHistoryListener(fHistoryListener); | |
| 1060 } | |
| 1061 } | |
| 1062 | |
| 1063 /** | |
| 1064 * Adds the given command to the operation history if it is not part of | |
| 1065 * a compound change. | |
| 1066 * | |
| 1067 * @param command the command to be added | |
| 1068 * @since 3.1 | |
| 1069 */ | |
| 1070 private void addToCommandStack(TextCommand command){ | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
1071 if (!fFoldingIntoCompoundChange || cast(CompoundTextCommand)command ) { |
| 129 | 1072 fHistory.add(command); |
| 1073 fLastAddedCommand= command; | |
| 1074 } | |
| 1075 } | |
| 1076 | |
| 1077 /** | |
| 1078 * Disposes the command stack. | |
| 1079 * | |
| 1080 * @since 3.1 | |
| 1081 */ | |
| 1082 private void disposeCommandStack() { | |
| 1083 fHistory.dispose(fUndoContext, true, true, true); | |
| 1084 } | |
| 1085 | |
| 1086 /** | |
| 1087 * Initializes the command stack. | |
| 1088 * | |
| 1089 * @since 3.1 | |
| 1090 */ | |
| 1091 private void initializeCommandStack() { | |
| 1092 if (fHistory !is null && fUndoContext !is null) | |
| 1093 fHistory.dispose(fUndoContext, true, true, false); | |
| 1094 | |
| 1095 } | |
| 1096 | |
| 1097 /** | |
| 1098 * Switches the state of whether there is a text listener or not. | |
| 1099 * | |
| 1100 * @param listen the state which should be established | |
| 1101 */ | |
| 1102 private void listenToTextChanges(bool listen) { | |
| 1103 if (listen) { | |
| 1104 if (fDocumentListener is null && fTextViewer.getDocument() !is null) { | |
| 1105 fDocumentListener= new DocumentListener(); | |
| 1106 fTextViewer.getDocument().addDocumentListener(fDocumentListener); | |
| 1107 } | |
| 1108 } else if (!listen) { | |
| 1109 if (fDocumentListener !is null && fTextViewer.getDocument() !is null) { | |
| 1110 fTextViewer.getDocument().removeDocumentListener(fDocumentListener); | |
| 1111 fDocumentListener= null; | |
| 1112 } | |
| 1113 } | |
| 1114 } | |
| 1115 | |
| 1116 /** | |
| 1117 * Closes the current editing command and opens a new one. | |
| 1118 */ | |
| 1119 private void commit() { | |
| 1120 // if fCurrent has never been placed on the command stack, do so now. | |
| 1121 // this can happen when there are multiple programmatically commits in a single | |
| 1122 // document change. | |
| 1123 if (fLastAddedCommand !is fCurrent) { | |
| 1124 fCurrent.pretendCommit(); | |
| 1125 if (fCurrent.isValid()) | |
| 1126 addToCommandStack(fCurrent); | |
| 1127 } | |
| 1128 fCurrent.commit(); | |
| 1129 } | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
1130 |
| 129 | 1131 /** |
| 1132 * Reset processChange state. | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
1133 * |
| 129 | 1134 * @since 3.2 |
| 1135 */ | |
| 1136 private void resetProcessChangeSate() { | |
| 1137 fInserting= false; | |
| 1138 fOverwriting= false; | |
| 1139 fPreviousDelete.reinitialize(); | |
| 1140 } | |
| 1141 | |
| 1142 /** | |
| 1143 * Checks whether the given text starts with a line delimiter and | |
| 1144 * subsequently contains a white space only. | |
| 1145 * | |
| 1146 * @param text the text to check | |
| 1147 * @return <code>true</code> if the text is a line delimiter followed by whitespace, <code>false</code> otherwise | |
| 1148 */ | |
| 1149 private bool isWhitespaceText(String text) { | |
| 1150 | |
| 1151 if (text is null || text.length() is 0) | |
| 1152 return false; | |
| 1153 | |
| 1154 String[] delimiters= fTextViewer.getDocument().getLegalLineDelimiters(); | |
| 1155 int index= TextUtilities.startsWith(delimiters, text); | |
| 1156 if (index > -1) { | |
| 1157 char c; | |
| 1158 int length= text.length(); | |
| 1159 for (int i= delimiters[index].length(); i < length; i++) { | |
| 1160 c= text.charAt(i); | |
| 1161 if (c !is ' ' && c !is '\t') | |
| 1162 return false; | |
| 1163 } | |
| 1164 return true; | |
| 1165 } | |
| 1166 | |
| 1167 return false; | |
| 1168 } | |
| 1169 | |
| 1170 private void processChange(int modelStart, int modelEnd, String insertedText, String replacedText, long beforeChangeModificationStamp, long afterChangeModificationStamp) { | |
| 1171 | |
| 1172 if (insertedText is null) | |
| 1173 insertedText= ""; //$NON-NLS-1$ | |
| 1174 | |
| 1175 if (replacedText is null) | |
| 1176 replacedText= ""; //$NON-NLS-1$ | |
| 1177 | |
| 1178 int length= insertedText.length(); | |
| 1179 int diff= modelEnd - modelStart; | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
1180 |
| 129 | 1181 if (fCurrent.fUndoModificationStamp is IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP) |
| 1182 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; | |
| 1183 | |
| 1184 // normalize | |
| 1185 if (diff < 0) { | |
| 1186 int tmp= modelEnd; | |
| 1187 modelEnd= modelStart; | |
| 1188 modelStart= tmp; | |
| 1189 } | |
| 1190 | |
| 1191 if (modelStart is modelEnd) { | |
| 1192 // text will be inserted | |
| 1193 if ((length is 1) || isWhitespaceText(insertedText)) { | |
| 1194 // by typing or whitespace | |
| 1195 if (!fInserting || (modelStart !is fCurrent.fStart + fTextBuffer.length())) { | |
| 1196 fCurrent.fRedoModificationStamp= beforeChangeModificationStamp; | |
| 1197 if (fCurrent.attemptCommit()) | |
| 1198 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
1199 |
| 129 | 1200 fInserting= true; |
| 1201 } | |
| 1202 if (fCurrent.fStart < 0) | |
| 1203 fCurrent.fStart= fCurrent.fEnd= modelStart; | |
| 1204 if (length > 0) | |
| 1205 fTextBuffer.append(insertedText); | |
| 1206 } else if (length >= 0) { | |
| 1207 // by pasting or model manipulation | |
| 1208 fCurrent.fRedoModificationStamp= beforeChangeModificationStamp; | |
| 1209 if (fCurrent.attemptCommit()) | |
| 1210 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; | |
| 1211 | |
| 1212 fCurrent.fStart= fCurrent.fEnd= modelStart; | |
| 1213 fTextBuffer.append(insertedText); | |
| 1214 fCurrent.fRedoModificationStamp= afterChangeModificationStamp; | |
| 1215 if (fCurrent.attemptCommit()) | |
| 1216 fCurrent.fUndoModificationStamp= afterChangeModificationStamp; | |
| 1217 | |
| 1218 } | |
| 1219 } else { | |
| 1220 if (length is 0) { | |
| 1221 // text will be deleted by backspace or DEL key or empty clipboard | |
| 1222 length= replacedText.length(); | |
| 1223 String[] delimiters= fTextViewer.getDocument().getLegalLineDelimiters(); | |
| 1224 | |
| 1225 if ((length is 1) || TextUtilities.equals(delimiters, replacedText) > -1) { | |
| 1226 | |
| 1227 // whereby selection is empty | |
| 1228 | |
| 1229 if (fPreviousDelete.fStart is modelStart && fPreviousDelete.fEnd is modelEnd) { | |
| 1230 // repeated DEL | |
| 1231 | |
| 1232 // correct wrong settings of fCurrent | |
| 1233 if (fCurrent.fStart is modelEnd && fCurrent.fEnd is modelStart) { | |
| 1234 fCurrent.fStart= modelStart; | |
| 1235 fCurrent.fEnd= modelEnd; | |
| 1236 } | |
| 1237 // append to buffer && extend command range | |
| 1238 fPreservedTextBuffer.append(replacedText); | |
| 1239 ++fCurrent.fEnd; | |
| 1240 | |
| 1241 } else if (fPreviousDelete.fStart is modelEnd) { | |
| 1242 // repeated backspace | |
| 1243 | |
| 1244 // insert in buffer and extend command range | |
| 1245 fPreservedTextBuffer.insert(0, replacedText); | |
| 1246 fCurrent.fStart= modelStart; | |
| 1247 | |
| 1248 } else { | |
| 1249 // either DEL or backspace for the first time | |
| 1250 | |
| 1251 fCurrent.fRedoModificationStamp= beforeChangeModificationStamp; | |
| 1252 if (fCurrent.attemptCommit()) | |
| 1253 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; | |
| 1254 | |
| 1255 // as we can not decide whether it was DEL or backspace we initialize for backspace | |
| 1256 fPreservedTextBuffer.append(replacedText); | |
| 1257 fCurrent.fStart= modelStart; | |
| 1258 fCurrent.fEnd= modelEnd; | |
| 1259 } | |
| 1260 | |
| 1261 fPreviousDelete.set(modelStart, modelEnd); | |
| 1262 | |
| 1263 } else if (length > 0) { | |
| 1264 // whereby selection is not empty | |
| 1265 fCurrent.fRedoModificationStamp= beforeChangeModificationStamp; | |
| 1266 if (fCurrent.attemptCommit()) | |
| 1267 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; | |
| 1268 | |
| 1269 fCurrent.fStart= modelStart; | |
| 1270 fCurrent.fEnd= modelEnd; | |
| 1271 fPreservedTextBuffer.append(replacedText); | |
| 1272 } | |
| 1273 } else { | |
| 1274 // text will be replaced | |
| 1275 | |
| 1276 if (length is 1) { | |
| 1277 length= replacedText.length(); | |
| 1278 String[] delimiters= fTextViewer.getDocument().getLegalLineDelimiters(); | |
| 1279 | |
| 1280 if ((length is 1) || TextUtilities.equals(delimiters, replacedText) > -1) { | |
| 1281 // because of overwrite mode or model manipulation | |
| 1282 if (!fOverwriting || (modelStart !is fCurrent.fStart + fTextBuffer.length())) { | |
| 1283 fCurrent.fRedoModificationStamp= beforeChangeModificationStamp; | |
| 1284 if (fCurrent.attemptCommit()) | |
| 1285 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; | |
| 1286 | |
| 1287 fOverwriting= true; | |
| 1288 } | |
| 1289 | |
| 1290 if (fCurrent.fStart < 0) | |
| 1291 fCurrent.fStart= modelStart; | |
| 1292 | |
| 1293 fCurrent.fEnd= modelEnd; | |
| 1294 fTextBuffer.append(insertedText); | |
| 1295 fPreservedTextBuffer.append(replacedText); | |
| 1296 fCurrent.fRedoModificationStamp= afterChangeModificationStamp; | |
| 1297 return; | |
| 1298 } | |
| 1299 } | |
| 1300 // because of typing or pasting whereby selection is not empty | |
| 1301 fCurrent.fRedoModificationStamp= beforeChangeModificationStamp; | |
| 1302 if (fCurrent.attemptCommit()) | |
|
140
26688fec6d23
Following dsss compile errors
Frank Benoit <benoit@tionex.de>
parents:
138
diff
changeset
|
1303 fCurrent.fUndoModificationStamp= beforeChangeModificationStamp; |
| 129 | 1304 |
| 1305 fCurrent.fStart= modelStart; | |
| 1306 fCurrent.fEnd= modelEnd; | |
| 1307 fTextBuffer.append(insertedText); | |
| 1308 fPreservedTextBuffer.append(replacedText); | |
| 1309 } | |
| 1310 } | |
| 1311 // in all cases, the redo modification stamp is updated on the open command | |
| 1312 fCurrent.fRedoModificationStamp= afterChangeModificationStamp; | |
| 1313 } | |
| 1314 | |
| 1315 /** | |
| 1316 * Shows the given exception in an error dialog. | |
| 1317 * | |
| 1318 * @param title the dialog title | |
| 1319 * @param ex the exception | |
| 1320 * @since 3.1 | |
| 1321 */ | |
| 156 | 1322 private void openErrorDialog(String title, Exception ex) { |
| 129 | 1323 Shell shell= null; |
| 1324 if (isConnected()) { | |
| 1325 StyledText st= fTextViewer.getTextWidget(); | |
| 1326 if (st !is null && !st.isDisposed()) | |
| 1327 shell= st.getShell(); | |
| 1328 } | |
| 1329 if (Display.getCurrent() !is null) | |
| 1330 MessageDialog.openError(shell, title, ex.getLocalizedMessage()); | |
| 1331 else { | |
| 1332 Display display; | |
| 156 | 1333 Shell finalShell= shell; |
| 129 | 1334 if (finalShell !is null) |
| 1335 display= finalShell.getDisplay(); | |
| 1336 else | |
| 1337 display= Display.getDefault(); | |
| 156 | 1338 display.syncExec(dgRunnable( { |
| 1339 MessageDialog.openError(finalShell, title, ex.getLocalizedMessage()); | |
| 1340 })); | |
| 129 | 1341 } |
| 1342 } | |
| 1343 | |
| 1344 /* | |
| 1345 * @see dwtx.jface.text.IUndoManager#setMaximalUndoLevel(int) | |
| 1346 */ | |
| 1347 public void setMaximalUndoLevel(int undoLevel) { | |
| 1348 fUndoLevel= Math.max(0, undoLevel); | |
| 1349 if (isConnected()) { | |
| 1350 fHistory.setLimit(fUndoContext, fUndoLevel); | |
| 1351 } | |
| 1352 } | |
| 1353 | |
| 1354 /* | |
| 1355 * @see dwtx.jface.text.IUndoManager#connect(dwtx.jface.text.ITextViewer) | |
| 1356 */ | |
| 1357 public void connect(ITextViewer textViewer) { | |
| 1358 if (!isConnected() && textViewer !is null) { | |
| 1359 fTextViewer= textViewer; | |
| 1360 if (fUndoContext is null) | |
| 1361 fUndoContext= new ObjectUndoContext(this); | |
| 1362 | |
| 1363 fHistory.setLimit(fUndoContext, fUndoLevel); | |
| 1364 | |
| 1365 initializeCommandStack(); | |
| 1366 | |
| 1367 // open up the current command | |
| 1368 fCurrent= new TextCommand(fUndoContext); | |
| 1369 | |
| 1370 fPreviousDelete= new TextCommand(fUndoContext); | |
| 1371 addListeners(); | |
| 1372 } | |
| 1373 } | |
| 1374 | |
| 1375 /* | |
| 1376 * @see dwtx.jface.text.IUndoManager#disconnect() | |
| 1377 */ | |
| 1378 public void disconnect() { | |
| 1379 if (isConnected()) { | |
| 1380 | |
| 1381 removeListeners(); | |
| 1382 | |
| 1383 fCurrent= null; | |
| 1384 fTextViewer= null; | |
| 1385 disposeCommandStack(); | |
| 1386 fTextBuffer= null; | |
| 1387 fPreservedTextBuffer= null; | |
| 1388 fUndoContext= null; | |
| 1389 } | |
| 1390 } | |
| 1391 | |
| 1392 /* | |
| 1393 * @see dwtx.jface.text.IUndoManager#reset() | |
| 1394 */ | |
| 1395 public void reset() { | |
| 1396 if (isConnected()) { | |
| 1397 initializeCommandStack(); | |
| 1398 fCurrent= new TextCommand(fUndoContext); | |
| 1399 fFoldingIntoCompoundChange= false; | |
| 1400 fInserting= false; | |
| 1401 fOverwriting= false; | |
| 1402 fTextBuffer.setLength(0); | |
| 1403 fPreservedTextBuffer.setLength(0); | |
| 1404 fPreservedUndoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 1405 fPreservedRedoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP; | |
| 1406 } | |
| 1407 } | |
| 1408 | |
| 1409 /* | |
| 1410 * @see dwtx.jface.text.IUndoManager#redoable() | |
| 1411 */ | |
| 1412 public bool redoable() { | |
| 1413 return fHistory.canRedo(fUndoContext); | |
| 1414 } | |
| 1415 | |
| 1416 /* | |
| 1417 * @see dwtx.jface.text.IUndoManager#undoable() | |
| 1418 */ | |
| 1419 public bool undoable() { | |
| 1420 return fHistory.canUndo(fUndoContext); | |
| 1421 } | |
| 1422 | |
| 1423 /* | |
| 1424 * @see dwtx.jface.text.IUndoManager#redo() | |
| 1425 */ | |
| 1426 public void redo() { | |
| 1427 if (isConnected() && redoable()) { | |
| 1428 try { | |
| 1429 fHistory.redo(fUndoContext, null, null); | |
| 1430 } catch (ExecutionException ex) { | |
| 1431 openErrorDialog(JFaceTextMessages.getString("DefaultUndoManager.error.redoFailed.title"), ex); //$NON-NLS-1$ | |
| 1432 } | |
| 1433 } | |
| 1434 } | |
| 1435 | |
| 1436 /* | |
| 1437 * @see dwtx.jface.text.IUndoManager#undo() | |
| 1438 */ | |
| 1439 public void undo() { | |
| 1440 if (isConnected() && undoable()) { | |
| 1441 try { | |
| 1442 fHistory.undo(fUndoContext, null, null); | |
| 1443 } catch (ExecutionException ex) { | |
| 1444 openErrorDialog(JFaceTextMessages.getString("DefaultUndoManager.error.undoFailed.title"), ex); //$NON-NLS-1$ | |
| 1445 } | |
| 1446 } | |
| 1447 } | |
| 1448 | |
| 1449 /** | |
| 1450 * Selects and reveals the specified range. | |
| 1451 * | |
| 1452 * @param offset the offset of the range | |
| 1453 * @param length the length of the range | |
| 1454 * @since 3.0 | |
| 1455 */ | |
| 1456 protected void selectAndReveal(int offset, int length) { | |
| 138 | 1457 if ( cast(ITextViewerExtension5)fTextViewer ) { |
| 134 | 1458 ITextViewerExtension5 extension= cast(ITextViewerExtension5) fTextViewer; |
| 129 | 1459 extension.exposeModelRange(new Region(offset, length)); |
| 1460 } else if (!fTextViewer.overlapsWithVisibleRegion(offset, length)) | |
| 1461 fTextViewer.resetVisibleRegion(); | |
| 1462 | |
| 1463 fTextViewer.setSelectedRange(offset, length); | |
| 1464 fTextViewer.revealRange(offset, length); | |
| 1465 } | |
| 1466 | |
| 1467 /* | |
| 1468 * @see dwtx.jface.text.IUndoManagerExtension#getUndoContext() | |
| 1469 * @since 3.1 | |
| 1470 */ | |
| 1471 public IUndoContext getUndoContext() { | |
| 1472 return fUndoContext; | |
| 1473 } | |
| 1474 | |
| 1475 } |