Mercurial > projects > dwt-addons
annotate dwtx/jface/text/source/CompositeRuler.d @ 162:1a5b8f8129df
...
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Mon, 08 Sep 2008 00:51:37 +0200 |
parents | 25f1f92fa3df |
children |
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 module dwtx.jface.text.source.CompositeRuler; | |
14 | |
131 | 15 import dwtx.jface.text.source.ISharedTextColors; // packageimport |
16 import dwtx.jface.text.source.ILineRange; // packageimport | |
17 import dwtx.jface.text.source.IAnnotationPresentation; // packageimport | |
18 import dwtx.jface.text.source.IVerticalRulerInfoExtension; // packageimport | |
19 import dwtx.jface.text.source.ICharacterPairMatcher; // packageimport | |
20 import dwtx.jface.text.source.TextInvocationContext; // packageimport | |
21 import dwtx.jface.text.source.LineChangeHover; // packageimport | |
22 import dwtx.jface.text.source.IChangeRulerColumn; // packageimport | |
23 import dwtx.jface.text.source.IAnnotationMap; // packageimport | |
24 import dwtx.jface.text.source.IAnnotationModelListenerExtension; // packageimport | |
25 import dwtx.jface.text.source.ISourceViewerExtension2; // packageimport | |
26 import dwtx.jface.text.source.IAnnotationHover; // packageimport | |
27 import dwtx.jface.text.source.ContentAssistantFacade; // packageimport | |
28 import dwtx.jface.text.source.IAnnotationAccess; // packageimport | |
29 import dwtx.jface.text.source.IVerticalRulerExtension; // packageimport | |
30 import dwtx.jface.text.source.IVerticalRulerColumn; // packageimport | |
31 import dwtx.jface.text.source.LineNumberRulerColumn; // packageimport | |
32 import dwtx.jface.text.source.MatchingCharacterPainter; // packageimport | |
33 import dwtx.jface.text.source.IAnnotationModelExtension; // packageimport | |
34 import dwtx.jface.text.source.ILineDifferExtension; // packageimport | |
35 import dwtx.jface.text.source.DefaultCharacterPairMatcher; // packageimport | |
36 import dwtx.jface.text.source.LineNumberChangeRulerColumn; // packageimport | |
37 import dwtx.jface.text.source.IAnnotationAccessExtension; // packageimport | |
38 import dwtx.jface.text.source.ISourceViewer; // packageimport | |
39 import dwtx.jface.text.source.AnnotationModel; // packageimport | |
40 import dwtx.jface.text.source.ILineDifferExtension2; // packageimport | |
41 import dwtx.jface.text.source.IAnnotationModelListener; // packageimport | |
42 import dwtx.jface.text.source.IVerticalRuler; // packageimport | |
43 import dwtx.jface.text.source.DefaultAnnotationHover; // packageimport | |
44 import dwtx.jface.text.source.SourceViewer; // packageimport | |
45 import dwtx.jface.text.source.SourceViewerConfiguration; // packageimport | |
46 import dwtx.jface.text.source.AnnotationBarHoverManager; // packageimport | |
47 import dwtx.jface.text.source.ImageUtilities; // packageimport | |
48 import dwtx.jface.text.source.VisualAnnotationModel; // packageimport | |
49 import dwtx.jface.text.source.IAnnotationModel; // packageimport | |
50 import dwtx.jface.text.source.ISourceViewerExtension3; // packageimport | |
51 import dwtx.jface.text.source.ILineDiffInfo; // packageimport | |
52 import dwtx.jface.text.source.VerticalRulerEvent; // packageimport | |
53 import dwtx.jface.text.source.ChangeRulerColumn; // packageimport | |
54 import dwtx.jface.text.source.ILineDiffer; // packageimport | |
55 import dwtx.jface.text.source.AnnotationModelEvent; // packageimport | |
56 import dwtx.jface.text.source.AnnotationColumn; // packageimport | |
57 import dwtx.jface.text.source.AnnotationRulerColumn; // packageimport | |
58 import dwtx.jface.text.source.IAnnotationHoverExtension; // packageimport | |
59 import dwtx.jface.text.source.AbstractRulerColumn; // packageimport | |
60 import dwtx.jface.text.source.ISourceViewerExtension; // packageimport | |
61 import dwtx.jface.text.source.AnnotationMap; // packageimport | |
62 import dwtx.jface.text.source.IVerticalRulerInfo; // packageimport | |
63 import dwtx.jface.text.source.IAnnotationModelExtension2; // packageimport | |
64 import dwtx.jface.text.source.LineRange; // packageimport | |
65 import dwtx.jface.text.source.IAnnotationAccessExtension2; // packageimport | |
66 import dwtx.jface.text.source.VerticalRuler; // packageimport | |
67 import dwtx.jface.text.source.JFaceTextMessages; // packageimport | |
68 import dwtx.jface.text.source.IOverviewRuler; // packageimport | |
69 import dwtx.jface.text.source.Annotation; // packageimport | |
70 import dwtx.jface.text.source.IVerticalRulerListener; // packageimport | |
71 import dwtx.jface.text.source.ISourceViewerExtension4; // packageimport | |
72 import dwtx.jface.text.source.AnnotationPainter; // packageimport | |
73 import dwtx.jface.text.source.IAnnotationHoverExtension2; // packageimport | |
74 import dwtx.jface.text.source.OverviewRuler; // packageimport | |
75 import dwtx.jface.text.source.OverviewRulerHoverManager; // packageimport | |
76 | |
129 | 77 import dwt.dwthelper.utils; |
153
f70d9508c95c
Fix java Collection imports
Frank Benoit <benoit@tionex.de>
parents:
145
diff
changeset
|
78 import dwtx.dwtxhelper.Collection; |
129 | 79 |
80 import dwt.DWT; | |
81 import dwt.custom.StyledText; | |
82 import dwt.events.ControlListener; | |
83 import dwt.events.DisposeEvent; | |
84 import dwt.events.DisposeListener; | |
85 import dwt.events.FocusListener; | |
86 import dwt.events.HelpListener; | |
87 import dwt.events.KeyListener; | |
88 import dwt.events.MouseListener; | |
89 import dwt.events.MouseMoveListener; | |
90 import dwt.events.MouseTrackListener; | |
91 import dwt.events.PaintListener; | |
92 import dwt.events.TraverseListener; | |
93 import dwt.graphics.Font; | |
94 import dwt.graphics.Point; | |
95 import dwt.graphics.Rectangle; | |
96 import dwt.widgets.Canvas; | |
97 import dwt.widgets.Composite; | |
98 import dwt.widgets.Control; | |
99 import dwt.widgets.Display; | |
100 import dwt.widgets.Event; | |
101 import dwt.widgets.Layout; | |
102 import dwt.widgets.Listener; | |
103 import dwt.widgets.Menu; | |
104 import dwtx.core.runtime.Assert; | |
105 import dwtx.jface.text.BadLocationException; | |
106 import dwtx.jface.text.IDocument; | |
107 import dwtx.jface.text.IRegion; | |
108 import dwtx.jface.text.ITextViewer; | |
109 import dwtx.jface.text.ITextViewerExtension; | |
110 import dwtx.jface.text.ITextViewerExtension5; | |
111 | |
112 | |
113 /** | |
114 * Standard implementation of | |
115 * {@link dwtx.jface.text.source.IVerticalRuler}. | |
116 * <p> | |
117 * This ruler does not have a a visual representation of its own. The | |
118 * presentation comes from the configurable list of vertical ruler columns. Such | |
119 * columns must implement the | |
120 * {@link dwtx.jface.text.source.IVerticalRulerColumn}. interface.</p> | |
121 * <p> | |
122 * Clients may instantiate and configure this class.</p> | |
123 * | |
124 * @see dwtx.jface.text.source.IVerticalRulerColumn | |
125 * @see dwtx.jface.text.ITextViewer | |
126 * @since 2.0 | |
127 */ | |
128 public class CompositeRuler : IVerticalRuler, IVerticalRulerExtension, IVerticalRulerInfoExtension { | |
129 | |
130 | |
131 /** | |
132 * Layout of the composite vertical ruler. Arranges the list of columns. | |
133 */ | |
134 class RulerLayout : Layout { | |
135 | |
136 /** | |
137 * Creates the new ruler layout. | |
138 */ | |
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
139 protected this() { |
129 | 140 } |
141 | |
142 /* | |
143 * @see Layout#computeSize(Composite, int, int, bool) | |
144 */ | |
145 protected Point computeSize(Composite composite, int wHint, int hHint, bool flushCache) { | |
146 Control[] children= composite.getChildren(); | |
147 Point size= new Point(0, 0); | |
148 for (int i= 0; i < children.length; i++) { | |
149 Point s= children[i].computeSize(DWT.DEFAULT, DWT.DEFAULT, flushCache); | |
150 size.x += s.x; | |
151 size.y= Math.max(size.y, s.y); | |
152 } | |
153 size.x += (Math.max(0, children.length -1) * fGap); | |
154 return size; | |
155 } | |
156 | |
157 /* | |
158 * @see Layout#layout(Composite, bool) | |
159 */ | |
160 protected void layout(Composite composite, bool flushCache) { | |
161 Rectangle clArea= composite.getClientArea(); | |
162 int rulerHeight= clArea.height; | |
163 | |
164 int x= 0; | |
165 Iterator e= fDecorators.iterator(); | |
166 while (e.hasNext()) { | |
134 | 167 IVerticalRulerColumn column= cast(IVerticalRulerColumn) e.next(); |
129 | 168 int columnWidth= column.getWidth(); |
169 column.getControl().setBounds(x, 0, columnWidth, rulerHeight); | |
170 x += (columnWidth + fGap); | |
171 } | |
172 } | |
173 } | |
174 | |
175 /** | |
176 * A canvas that adds listeners to all its children. Used by the implementation of the | |
177 * vertical ruler to propagate listener additions and removals to the ruler's columns. | |
178 */ | |
179 static class CompositeRulerCanvas : Canvas { | |
180 | |
181 /** | |
182 * Keeps the information for which event type a listener object has been added. | |
183 */ | |
184 static class ListenerInfo { | |
158 | 185 ClassInfo fClass; |
129 | 186 EventListener fListener; |
187 } | |
188 | |
189 /** The list of listeners added to this canvas. */ | |
162 | 190 private List fCachedListeners; |
129 | 191 /** |
192 * Internal listener for opening the context menu. | |
193 * @since 3.0 | |
194 */ | |
195 private Listener fMenuDetectListener; | |
196 | |
197 /** | |
198 * Creates a new composite ruler canvas. | |
199 * | |
200 * @param parent the parent composite | |
201 * @param style the DWT styles | |
202 */ | |
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
203 public this(Composite parent, int style) { |
162 | 204 fCachedListeners= new ArrayList(); |
205 | |
129 | 206 super(parent, style); |
135 | 207 fMenuDetectListener= new class() Listener { |
129 | 208 public void handleEvent(Event event) { |
209 if (event.type is DWT.MenuDetect) { | |
210 Menu menu= getMenu(); | |
211 if (menu !is null) { | |
212 menu.setLocation(event.x, event.y); | |
213 menu.setVisible(true); | |
214 } | |
215 } | |
216 } | |
217 }; | |
135 | 218 super.addDisposeListener(new class() DisposeListener { |
129 | 219 public void widgetDisposed(DisposeEvent e) { |
220 if (fCachedListeners !is null) { | |
221 fCachedListeners.clear(); | |
222 fCachedListeners= null; | |
223 } | |
224 } | |
225 }); | |
226 } | |
227 | |
228 /** | |
229 * Adds the given listener object as listener of the given type (<code>clazz</code>) to | |
230 * the given control. | |
231 * | |
232 * @param clazz the listener type | |
233 * @param control the control to add the listener to | |
234 * @param listener the listener to be added | |
235 */ | |
158 | 236 private void addListener(ClassInfo clazz, Control control, EventListener listener) { |
145 | 237 if (ControlListener.classinfo.opEquals(clazz)) { |
134 | 238 control. addControlListener(cast(ControlListener) listener); |
129 | 239 return; |
240 } | |
145 | 241 if (FocusListener.classinfo.opEquals(clazz)) { |
134 | 242 control. addFocusListener(cast(FocusListener) listener); |
129 | 243 return; |
244 } | |
145 | 245 if (HelpListener.classinfo.opEquals(clazz)) { |
134 | 246 control. addHelpListener(cast(HelpListener) listener); |
129 | 247 return; |
248 } | |
145 | 249 if (KeyListener.classinfo.opEquals(clazz)) { |
134 | 250 control. addKeyListener(cast(KeyListener) listener); |
129 | 251 return; |
252 } | |
145 | 253 if (MouseListener.classinfo.opEquals(clazz)) { |
134 | 254 control. addMouseListener(cast(MouseListener) listener); |
129 | 255 return; |
256 } | |
145 | 257 if (MouseMoveListener.classinfo.opEquals(clazz)) { |
134 | 258 control. addMouseMoveListener(cast(MouseMoveListener) listener); |
129 | 259 return; |
260 } | |
145 | 261 if (MouseTrackListener.classinfo.opEquals(clazz)) { |
134 | 262 control. addMouseTrackListener(cast(MouseTrackListener) listener); |
129 | 263 return; |
264 } | |
145 | 265 if (PaintListener.classinfo.opEquals(clazz)) { |
134 | 266 control. addPaintListener(cast(PaintListener) listener); |
129 | 267 return; |
268 } | |
145 | 269 if (TraverseListener.classinfo.opEquals(clazz)) { |
134 | 270 control. addTraverseListener(cast(TraverseListener) listener); |
129 | 271 return; |
272 } | |
145 | 273 if (DisposeListener.classinfo.opEquals(clazz)) { |
134 | 274 control. addDisposeListener(cast(DisposeListener) listener); |
129 | 275 return; |
276 } | |
277 } | |
278 | |
279 /** | |
280 * Removes the given listener object as listener of the given type (<code>clazz</code>) from | |
281 * the given control. | |
282 * | |
283 * @param clazz the listener type | |
284 * @param control the control to remove the listener from | |
285 * @param listener the listener to be removed | |
286 */ | |
158 | 287 private void removeListener(ClassInfo clazz, Control control, EventListener listener) { |
145 | 288 if (ControlListener.classinfo.opEquals(clazz)) { |
134 | 289 control. removeControlListener(cast(ControlListener) listener); |
129 | 290 return; |
291 } | |
145 | 292 if (FocusListener.classinfo.opEquals(clazz)) { |
134 | 293 control. removeFocusListener(cast(FocusListener) listener); |
129 | 294 return; |
295 } | |
145 | 296 if (HelpListener.classinfo.opEquals(clazz)) { |
134 | 297 control. removeHelpListener(cast(HelpListener) listener); |
129 | 298 return; |
299 } | |
145 | 300 if (KeyListener.classinfo.opEquals(clazz)) { |
134 | 301 control. removeKeyListener(cast(KeyListener) listener); |
129 | 302 return; |
303 } | |
145 | 304 if (MouseListener.classinfo.opEquals(clazz)) { |
134 | 305 control. removeMouseListener(cast(MouseListener) listener); |
129 | 306 return; |
307 } | |
145 | 308 if (MouseMoveListener.classinfo.opEquals(clazz)) { |
134 | 309 control. removeMouseMoveListener(cast(MouseMoveListener) listener); |
129 | 310 return; |
311 } | |
145 | 312 if (MouseTrackListener.classinfo.opEquals(clazz)) { |
134 | 313 control. removeMouseTrackListener(cast(MouseTrackListener) listener); |
129 | 314 return; |
315 } | |
145 | 316 if (PaintListener.classinfo.opEquals(clazz)) { |
134 | 317 control. removePaintListener(cast(PaintListener) listener); |
129 | 318 return; |
319 } | |
145 | 320 if (TraverseListener.classinfo.opEquals(clazz)) { |
134 | 321 control. removeTraverseListener(cast(TraverseListener) listener); |
129 | 322 return; |
323 } | |
145 | 324 if (DisposeListener.classinfo.opEquals(clazz)) { |
134 | 325 control. removeDisposeListener(cast(DisposeListener) listener); |
129 | 326 return; |
327 } | |
328 } | |
329 | |
330 /** | |
331 * Adds the given listener object to the internal book keeping under | |
332 * the given listener type (<code>clazz</code>). | |
333 * | |
334 * @param clazz the listener type | |
335 * @param listener the listener object | |
336 */ | |
158 | 337 private void addListener(ClassInfo clazz, EventListener listener) { |
129 | 338 Control[] children= getChildren(); |
339 for (int i= 0; i < children.length; i++) { | |
340 if (children[i] !is null && !children[i].isDisposed()) | |
341 addListener(clazz, children[i], listener); | |
342 } | |
343 | |
344 ListenerInfo info= new ListenerInfo(); | |
345 info.fClass= clazz; | |
346 info.fListener= listener; | |
347 fCachedListeners.add(info); | |
348 } | |
349 | |
350 /** | |
351 * Removes the given listener object from the internal book keeping under | |
352 * the given listener type (<code>clazz</code>). | |
353 * | |
354 * @param clazz the listener type | |
355 * @param listener the listener object | |
356 */ | |
158 | 357 private void removeListener(ClassInfo clazz, EventListener listener) { |
129 | 358 int length= fCachedListeners.size(); |
359 for (int i= 0; i < length; i++) { | |
134 | 360 ListenerInfo info= cast(ListenerInfo) fCachedListeners.get(i); |
162 | 361 if (listener is info.fListener && clazz.opEquals(info.fClass)) { |
129 | 362 fCachedListeners.remove(i); |
363 break; | |
364 } | |
365 } | |
366 | |
367 Control[] children= getChildren(); | |
368 for (int i= 0; i < children.length; i++) { | |
369 if (children[i] !is null && !children[i].isDisposed()) | |
370 removeListener(clazz, children[i], listener); | |
371 } | |
372 } | |
373 | |
374 /** | |
375 * Tells this canvas that a child has been added. | |
376 * | |
377 * @param child the child | |
378 */ | |
379 public void childAdded(Control child) { | |
380 if (child !is null && !child.isDisposed()) { | |
381 int length= fCachedListeners.size(); | |
382 for (int i= 0; i < length; i++) { | |
134 | 383 ListenerInfo info= cast(ListenerInfo) fCachedListeners.get(i); |
129 | 384 addListener(info.fClass, child, info.fListener); |
385 } | |
386 child.addListener(DWT.MenuDetect, fMenuDetectListener); | |
387 } | |
388 } | |
389 | |
390 /** | |
391 * Tells this canvas that a child has been removed. | |
392 * | |
393 * @param child the child | |
394 */ | |
395 public void childRemoved(Control child) { | |
396 if (child !is null && !child.isDisposed()) { | |
397 int length= fCachedListeners.size(); | |
398 for (int i= 0; i < length; i++) { | |
134 | 399 ListenerInfo info= cast(ListenerInfo) fCachedListeners.get(i); |
129 | 400 removeListener(info.fClass, child, info.fListener); |
401 } | |
402 child.removeListener(DWT.MenuDetect, fMenuDetectListener); | |
403 } | |
404 } | |
405 | |
406 /* | |
407 * @see Control#removeControlListener(ControlListener) | |
408 */ | |
409 public void removeControlListener(ControlListener listener) { | |
145 | 410 removeListener(ControlListener.classinfo, listener); |
129 | 411 super.removeControlListener(listener); |
412 } | |
413 | |
414 /* | |
415 * @see Control#removeFocusListener(FocusListener) | |
416 */ | |
417 public void removeFocusListener(FocusListener listener) { | |
145 | 418 removeListener(FocusListener.classinfo, listener); |
129 | 419 super.removeFocusListener(listener); |
420 } | |
421 | |
422 /* | |
423 * @see Control#removeHelpListener(HelpListener) | |
424 */ | |
425 public void removeHelpListener(HelpListener listener) { | |
145 | 426 removeListener(HelpListener.classinfo, listener); |
129 | 427 super.removeHelpListener(listener); |
428 } | |
429 | |
430 /* | |
431 * @see Control#removeKeyListener(KeyListener) | |
432 */ | |
433 public void removeKeyListener(KeyListener listener) { | |
145 | 434 removeListener(KeyListener.classinfo, listener); |
129 | 435 super.removeKeyListener(listener); |
436 } | |
437 | |
438 /* | |
439 * @see Control#removeMouseListener(MouseListener) | |
440 */ | |
441 public void removeMouseListener(MouseListener listener) { | |
145 | 442 removeListener(MouseListener.classinfo, listener); |
129 | 443 super.removeMouseListener(listener); |
444 } | |
445 | |
446 /* | |
447 * @see Control#removeMouseMoveListener(MouseMoveListener) | |
448 */ | |
449 public void removeMouseMoveListener(MouseMoveListener listener) { | |
145 | 450 removeListener(MouseMoveListener.classinfo, listener); |
129 | 451 super.removeMouseMoveListener(listener); |
452 } | |
453 | |
454 /* | |
455 * @see Control#removeMouseTrackListener(MouseTrackListener) | |
456 */ | |
457 public void removeMouseTrackListener(MouseTrackListener listener) { | |
145 | 458 removeListener(MouseTrackListener.classinfo, listener); |
129 | 459 super.removeMouseTrackListener(listener); |
460 } | |
461 | |
462 /* | |
463 * @see Control#removePaintListener(PaintListener) | |
464 */ | |
465 public void removePaintListener(PaintListener listener) { | |
145 | 466 removeListener(PaintListener.classinfo, listener); |
129 | 467 super.removePaintListener(listener); |
468 } | |
469 | |
470 /* | |
471 * @see Control#removeTraverseListener(TraverseListener) | |
472 */ | |
473 public void removeTraverseListener(TraverseListener listener) { | |
145 | 474 removeListener(TraverseListener.classinfo, listener); |
129 | 475 super.removeTraverseListener(listener); |
476 } | |
477 | |
478 /* | |
479 * @see Widget#removeDisposeListener(DisposeListener) | |
480 */ | |
481 public void removeDisposeListener(DisposeListener listener) { | |
145 | 482 removeListener(DisposeListener.classinfo, listener); |
129 | 483 super.removeDisposeListener(listener); |
484 } | |
485 | |
486 /* | |
487 * @seeControl#addControlListener(ControlListener) | |
488 */ | |
489 public void addControlListener(ControlListener listener) { | |
490 super.addControlListener(listener); | |
145 | 491 addListener(ControlListener.classinfo, listener); |
129 | 492 } |
493 | |
494 /* | |
495 * @see Control#addFocusListener(FocusListener) | |
496 */ | |
497 public void addFocusListener(FocusListener listener) { | |
498 super.addFocusListener(listener); | |
145 | 499 addListener(FocusListener.classinfo, listener); |
129 | 500 } |
501 | |
502 /* | |
503 * @see Control#addHelpListener(HelpListener) | |
504 */ | |
505 public void addHelpListener(HelpListener listener) { | |
506 super.addHelpListener(listener); | |
145 | 507 addListener(HelpListener.classinfo, listener); |
129 | 508 } |
509 | |
510 /* | |
511 * @see Control#addKeyListener(KeyListener) | |
512 */ | |
513 public void addKeyListener(KeyListener listener) { | |
514 super.addKeyListener(listener); | |
145 | 515 addListener(KeyListener.classinfo, listener); |
129 | 516 } |
517 | |
518 /* | |
519 * @see Control#addMouseListener(MouseListener) | |
520 */ | |
521 public void addMouseListener(MouseListener listener) { | |
522 super.addMouseListener(listener); | |
145 | 523 addListener(MouseListener.classinfo, listener); |
129 | 524 } |
525 | |
526 /* | |
527 * @see Control#addMouseMoveListener(MouseMoveListener) | |
528 */ | |
529 public void addMouseMoveListener(MouseMoveListener listener) { | |
530 super.addMouseMoveListener(listener); | |
145 | 531 addListener(MouseMoveListener.classinfo, listener); |
129 | 532 } |
533 | |
534 /* | |
535 * @see Control#addMouseTrackListener(MouseTrackListener) | |
536 */ | |
537 public void addMouseTrackListener(MouseTrackListener listener) { | |
538 super.addMouseTrackListener(listener); | |
145 | 539 addListener(MouseTrackListener.classinfo, listener); |
129 | 540 } |
541 | |
542 /* | |
543 * @seeControl#addPaintListener(PaintListener) | |
544 */ | |
545 public void addPaintListener(PaintListener listener) { | |
546 super.addPaintListener(listener); | |
145 | 547 addListener(PaintListener.classinfo, listener); |
129 | 548 } |
549 | |
550 /* | |
551 * @see Control#addTraverseListener(TraverseListener) | |
552 */ | |
553 public void addTraverseListener(TraverseListener listener) { | |
554 super.addTraverseListener(listener); | |
145 | 555 addListener(TraverseListener.classinfo, listener); |
129 | 556 } |
557 | |
558 /* | |
559 * @see Widget#addDisposeListener(DisposeListener) | |
560 */ | |
561 public void addDisposeListener(DisposeListener listener) { | |
562 super.addDisposeListener(listener); | |
145 | 563 addListener(DisposeListener.classinfo, listener); |
129 | 564 } |
565 } | |
566 | |
567 /** The ruler's viewer */ | |
568 private ITextViewer fTextViewer; | |
569 /** The ruler's canvas to which to add the ruler columns */ | |
570 private CompositeRulerCanvas fComposite; | |
571 /** The ruler's annotation model */ | |
572 private IAnnotationModel fModel; | |
573 /** The list of columns */ | |
162 | 574 private List fDecorators; |
129 | 575 /** The cached location of the last mouse button activity */ |
162 | 576 private Point fLocation; |
129 | 577 /** The cached line of the list mouse button activity */ |
578 private int fLastMouseButtonActivityLine= -1; | |
579 /** The gap between the individual columns of this composite ruler */ | |
580 private int fGap; | |
581 /** | |
582 * The set of annotation listeners. | |
583 * @since 3.0 | |
584 */ | |
162 | 585 private Set fAnnotationListeners; |
129 | 586 |
587 | |
588 /** | |
589 * Constructs a new composite vertical ruler. | |
590 */ | |
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
591 public this() { |
129 | 592 this(0); |
593 } | |
594 | |
595 /** | |
596 * Constructs a new composite ruler with the given gap between its columns. | |
597 * | |
598 * @param gap | |
599 */ | |
133
7d818bd32d63
Fix ctors to this with gvim regexp
Frank Benoit <benoit@tionex.de>
parents:
131
diff
changeset
|
600 public this(int gap) { |
162 | 601 fDecorators= new ArrayList(2); |
602 fLocation= new Point(-1, -1); | |
603 fAnnotationListeners= new HashSet(); | |
604 | |
129 | 605 fGap= gap; |
606 } | |
607 | |
608 /** | |
609 * Inserts the given column at the specified slot to this composite ruler. | |
610 * Columns are counted from left to right. | |
611 * | |
612 * @param index the index | |
613 * @param rulerColumn the decorator to be inserted | |
614 */ | |
615 public void addDecorator(int index, IVerticalRulerColumn rulerColumn) { | |
616 rulerColumn.setModel(getModel()); | |
617 | |
618 if (index > fDecorators.size()) | |
162 | 619 fDecorators.add(cast(Object)rulerColumn); |
129 | 620 else |
162 | 621 fDecorators.add(index, cast(Object)rulerColumn); |
129 | 622 |
623 if (fComposite !is null && !fComposite.isDisposed()) { | |
624 rulerColumn.createControl(this, fComposite); | |
625 fComposite.childAdded(rulerColumn.getControl()); | |
626 layoutTextViewer(); | |
627 } | |
628 } | |
629 | |
630 /** | |
631 * Removes the decorator in the specified slot from this composite ruler. | |
632 * | |
633 * @param index the index | |
634 */ | |
635 public void removeDecorator(int index) { | |
134 | 636 IVerticalRulerColumn rulerColumn= cast(IVerticalRulerColumn) fDecorators.get(index); |
129 | 637 removeDecorator(rulerColumn); |
638 } | |
639 | |
640 /** | |
641 * Removes the given decorator from the composite ruler. | |
642 * | |
643 * @param rulerColumn the ruler column to be removed | |
644 * @since 3.0 | |
645 */ | |
646 public void removeDecorator(IVerticalRulerColumn rulerColumn) { | |
162 | 647 fDecorators.remove(cast(Object)rulerColumn); |
129 | 648 if (rulerColumn !is null) { |
649 Control cc= rulerColumn.getControl(); | |
650 if (cc !is null && !cc.isDisposed()) { | |
651 fComposite.childRemoved(cc); | |
652 cc.dispose(); | |
653 } | |
654 } | |
655 layoutTextViewer(); | |
656 } | |
657 | |
658 /** | |
659 * Layouts the text viewer. This also causes this ruler to get | |
660 * be layouted. | |
661 */ | |
662 private void layoutTextViewer() { | |
663 | |
664 Control parent= fTextViewer.getTextWidget(); | |
665 | |
138 | 666 if ( cast(ITextViewerExtension)fTextViewer ) { |
134 | 667 ITextViewerExtension extension= cast(ITextViewerExtension) fTextViewer; |
129 | 668 parent= extension.getControl(); |
669 } | |
670 | |
142 | 671 if ( cast(Composite)parent && !parent.isDisposed()) |
134 | 672 (cast(Composite) parent).layout(true); |
129 | 673 } |
674 | |
675 /* | |
676 * @see IVerticalRuler#getControl() | |
677 */ | |
678 public Control getControl() { | |
679 return fComposite; | |
680 } | |
681 | |
682 /* | |
683 * @see IVerticalRuler#createControl(Composite, ITextViewer) | |
684 */ | |
685 public Control createControl(Composite parent, ITextViewer textViewer) { | |
686 | |
687 fTextViewer= textViewer; | |
688 | |
689 fComposite= new CompositeRulerCanvas(parent, DWT.NONE); | |
690 fComposite.setLayout(new RulerLayout()); | |
691 | |
692 Iterator iter= fDecorators.iterator(); | |
693 while (iter.hasNext()) { | |
134 | 694 IVerticalRulerColumn column= cast(IVerticalRulerColumn) iter.next(); |
129 | 695 column.createControl(this, fComposite); |
696 fComposite.childAdded(column.getControl()); | |
697 } | |
698 | |
699 return fComposite; | |
700 } | |
701 | |
702 /* | |
703 * @see IVerticalRuler#setModel(IAnnotationModel) | |
704 */ | |
705 public void setModel(IAnnotationModel model) { | |
706 | |
707 fModel= model; | |
708 | |
709 Iterator e= fDecorators.iterator(); | |
710 while (e.hasNext()) { | |
134 | 711 IVerticalRulerColumn column= cast(IVerticalRulerColumn) e.next(); |
129 | 712 column.setModel(model); |
713 } | |
714 } | |
715 | |
716 /* | |
717 * @see IVerticalRuler#getModel() | |
718 */ | |
719 public IAnnotationModel getModel() { | |
720 return fModel; | |
721 } | |
722 | |
723 /* | |
724 * @see IVerticalRuler#update() | |
725 */ | |
726 public void update() { | |
727 if (fComposite !is null && !fComposite.isDisposed()) { | |
728 Display d= fComposite.getDisplay(); | |
729 if (d !is null) { | |
135 | 730 d.asyncExec(new class() Runnable { |
129 | 731 public void run() { |
732 immediateUpdate(); | |
733 } | |
734 }); | |
735 } | |
736 } | |
737 } | |
145 | 738 |
129 | 739 /** |
740 * Immediately redraws the entire ruler (without asynchronous posting). | |
145 | 741 * |
129 | 742 * @since 3.2 |
743 */ | |
744 public void immediateUpdate() { | |
745 Iterator e= fDecorators.iterator(); | |
746 while (e.hasNext()) { | |
134 | 747 IVerticalRulerColumn column= cast(IVerticalRulerColumn) e.next(); |
129 | 748 column.redraw(); |
749 } | |
750 } | |
751 | |
752 /* | |
753 * @see IVerticalRulerExtension#setFont(Font) | |
754 */ | |
755 public void setFont(Font font) { | |
756 Iterator e= fDecorators.iterator(); | |
757 while (e.hasNext()) { | |
134 | 758 IVerticalRulerColumn column= cast(IVerticalRulerColumn) e.next(); |
129 | 759 column.setFont(font); |
760 } | |
761 } | |
762 | |
763 /* | |
764 * @see IVerticalRulerInfo#getWidth() | |
765 */ | |
766 public int getWidth() { | |
767 int width= 0; | |
768 Iterator e= fDecorators.iterator(); | |
769 while (e.hasNext()) { | |
134 | 770 IVerticalRulerColumn column= cast(IVerticalRulerColumn) e.next(); |
129 | 771 width += (column.getWidth() + fGap); |
772 } | |
773 return Math.max(0, width - fGap); | |
774 } | |
775 | |
776 /* | |
777 * @see IVerticalRulerInfo#getLineOfLastMouseButtonActivity() | |
778 */ | |
779 public int getLineOfLastMouseButtonActivity() { | |
780 if (fLastMouseButtonActivityLine is -1) | |
781 fLastMouseButtonActivityLine= toDocumentLineNumber(fLocation.y); | |
782 else if (fTextViewer.getDocument() is null || fLastMouseButtonActivityLine >= fTextViewer.getDocument().getNumberOfLines()) | |
783 fLastMouseButtonActivityLine= -1; | |
784 return fLastMouseButtonActivityLine; | |
785 } | |
786 | |
787 /* | |
788 * @see IVerticalRulerInfo#toDocumentLineNumber(int) | |
789 */ | |
790 public int toDocumentLineNumber(int y_coordinate) { | |
791 if (fTextViewer is null || y_coordinate is -1) | |
792 return -1; | |
793 | |
794 StyledText text= fTextViewer.getTextWidget(); | |
795 int line= text.getLineIndex(y_coordinate); | |
145 | 796 |
129 | 797 if (line is text.getLineCount() - 1) { |
798 // check whether y_coordinate exceeds last line | |
799 if (y_coordinate > text.getLinePixel(line + 1)) | |
800 return -1; | |
801 } | |
145 | 802 |
129 | 803 return widgetLine2ModelLine(fTextViewer, line); |
804 } | |
805 | |
806 /** | |
807 * Returns the line in the given viewer's document that correspond to the given | |
808 * line of the viewer's widget. | |
809 * | |
810 * @param viewer the viewer | |
811 * @param widgetLine the widget line | |
812 * @return the corresponding line the viewer's document | |
813 * @since 2.1 | |
814 */ | |
815 protected final static int widgetLine2ModelLine(ITextViewer viewer, int widgetLine) { | |
816 | |
138 | 817 if ( cast(ITextViewerExtension5)viewer ) { |
134 | 818 ITextViewerExtension5 extension= cast(ITextViewerExtension5) viewer; |
129 | 819 return extension.widgetLine2ModelLine(widgetLine); |
820 } | |
821 | |
822 try { | |
823 IRegion r= viewer.getVisibleRegion(); | |
824 IDocument d= viewer.getDocument(); | |
825 return widgetLine += d.getLineOfOffset(r.getOffset()); | |
826 } catch (BadLocationException x) { | |
827 } | |
828 return widgetLine; | |
829 } | |
830 | |
831 /** | |
832 * Returns this ruler's text viewer. | |
833 * | |
834 * @return this ruler's text viewer | |
835 */ | |
836 public ITextViewer getTextViewer() { | |
837 return fTextViewer; | |
838 } | |
839 | |
840 /* | |
841 * @see IVerticalRulerExtension#setLocationOfLastMouseButtonActivity(int, int) | |
842 */ | |
843 public void setLocationOfLastMouseButtonActivity(int x, int y) { | |
844 fLocation.x= x; | |
845 fLocation.y= y; | |
846 fLastMouseButtonActivityLine= -1; | |
847 } | |
848 | |
849 /** | |
850 * Returns an iterator over the <code>IVerticalRulerColumns</code> that make up this | |
851 * composite column. | |
852 * | |
853 * @return an iterator over the contained columns. | |
854 * @since 3.0 | |
855 */ | |
856 public Iterator getDecoratorIterator() { | |
162 | 857 Assert.isNotNull(cast(Object)fDecorators, "fDecorators must be initialized"); //$NON-NLS-1$ |
129 | 858 return fDecorators.iterator(); |
859 } | |
860 | |
861 /* | |
862 * @see dwtx.jface.text.source.IVerticalRulerInfoExtension#getHover() | |
863 * @since 3.0 | |
864 */ | |
865 public IAnnotationHover getHover() { | |
866 return null; | |
867 } | |
868 | |
869 /* | |
870 * @see dwtx.jface.text.source.IVerticalRulerInfoExtension#addVerticalRulerListener(dwtx.jface.text.source.IVerticalRulerListener) | |
871 * @since 3.0 | |
872 */ | |
873 public void addVerticalRulerListener(IVerticalRulerListener listener) { | |
162 | 874 fAnnotationListeners.add(cast(Object)listener); |
129 | 875 } |
876 | |
877 /* | |
878 * @see dwtx.jface.text.source.IVerticalRulerInfoExtension#removeVerticalRulerListener(dwtx.jface.text.source.IVerticalRulerListener) | |
879 * @since 3.0 | |
880 */ | |
881 public void removeVerticalRulerListener(IVerticalRulerListener listener) { | |
162 | 882 fAnnotationListeners.remove(cast(Object)listener); |
129 | 883 } |
884 | |
885 /** | |
886 * Fires the annotation selected event to all registered vertical ruler | |
887 * listeners. | |
888 * TODO use robust iterators | |
889 * | |
890 * @param event the event to fire | |
891 * @since 3.0 | |
892 */ | |
893 public void fireAnnotationSelected(VerticalRulerEvent event) { | |
894 // forward to listeners | |
895 for (Iterator it= fAnnotationListeners.iterator(); it.hasNext();) { | |
134 | 896 IVerticalRulerListener listener= cast(IVerticalRulerListener) it.next(); |
129 | 897 listener.annotationSelected(event); |
898 } | |
899 } | |
900 | |
901 /** | |
902 * Fires the annotation default selected event to all registered vertical | |
903 * ruler listeners. | |
904 * TODO use robust iterators | |
905 * | |
906 * @param event the event to fire | |
907 * @since 3.0 | |
908 */ | |
909 public void fireAnnotationDefaultSelected(VerticalRulerEvent event) { | |
910 // forward to listeners | |
911 for (Iterator it= fAnnotationListeners.iterator(); it.hasNext();) { | |
134 | 912 IVerticalRulerListener listener= cast(IVerticalRulerListener) it.next(); |
129 | 913 listener.annotationDefaultSelected(event); |
914 } | |
915 } | |
916 | |
917 /** | |
918 * Informs all registered vertical ruler listeners that the content menu on a selected annotation\ | |
919 * is about to be shown. | |
920 * TODO use robust iterators | |
921 * | |
922 * @param event the event to fire | |
923 * @param menu the menu that is about to be shown | |
924 * @since 3.0 | |
925 */ | |
926 public void fireAnnotationContextMenuAboutToShow(VerticalRulerEvent event, Menu menu) { | |
927 // forward to listeners | |
928 for (Iterator it= fAnnotationListeners.iterator(); it.hasNext();) { | |
134 | 929 IVerticalRulerListener listener= cast(IVerticalRulerListener) it.next(); |
129 | 930 listener.annotationContextMenuAboutToShow(event, menu); |
931 } | |
932 } | |
933 | |
934 /** | |
935 * Relayouts the receiver. | |
936 * | |
937 * @since 3.3 | |
938 */ | |
939 public void relayout() { | |
940 layoutTextViewer(); | |
941 } | |
942 } |