Mercurial > projects > dwt-addons

comparison dwtx/jface/text/source/projection/ProjectionSummary.d @ 129:eb30df5ca28b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added JFace Text sources
author Frank Benoit <benoit@tionex.de>
date Sat, 23 Aug 2008 19:10:48 +0200
parents
children c4fb132a086c
comparison
equal deleted inserted replaced
128:8df1d4193877 129:eb30df5ca28b
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.projection.ProjectionSummary;
14
15 import dwt.dwthelper.utils;
16
17
18 import java.util.ArrayList;
19 import java.util.HashMap;
20 import java.util.Iterator;
21 import java.util.List;
22 import java.util.Map;
23
24 import dwtx.core.runtime.IProgressMonitor;
25 import dwtx.core.runtime.NullProgressMonitor;
26 import dwtx.jface.text.IDocument;
27 import dwtx.jface.text.IRegion;
28 import dwtx.jface.text.ISynchronizable;
29 import dwtx.jface.text.Position;
30 import dwtx.jface.text.source.Annotation;
31 import dwtx.jface.text.source.IAnnotationAccess;
32 import dwtx.jface.text.source.IAnnotationAccessExtension;
33 import dwtx.jface.text.source.IAnnotationModel;
34 import dwtx.jface.text.source.IAnnotationModelExtension;
35
36
37 /**
38 * Strategy for managing annotation summaries for collapsed ranges.
39 *
40 * @since 3.0
41 */
42 class ProjectionSummary {
43
44 private class Summarizer : Thread {
45
46 private bool fReset= true;
47
48 /**
49 * Creates a new thread.
50 */
51 public Summarizer() {
52 fProgressMonitor= new NullProgressMonitor(); // might be given by client in the future
53 setDaemon(true);
54 start();
55 }
56
57 /**
58 * Resets the thread.
59 */
60 public void reset() {
61 synchronized (fLock) {
62 fReset= true;
63 fProgressMonitor.setCanceled(true);
64 }
65 }
66
67 /*
68 * @see java.lang.Thread#run()
69 */
70 public void run() {
71 while (true) {
72 synchronized (fLock) {
73 if (!fReset)
74 break;
75 fReset= false;
76 fProgressMonitor.setCanceled(false);
77 }
78 internalUpdateSummaries(fProgressMonitor);
79 }
80
81 synchronized (fLock) {
82 fSummarizer= null;
83 }
84 }
85 }
86
87
88 private ProjectionViewer fProjectionViewer;
89 private IAnnotationModel fAnnotationModel;
90 private IAnnotationAccess fAnnotationAccess;
91 private List fConfiguredAnnotationTypes;
92
93 private Object fLock= new Object();
94 private IProgressMonitor fProgressMonitor;
95 private volatile Summarizer fSummarizer;
96
97 /**
98 * Creates a new projection summary.
99 *
100 * @param projectionViewer the projection viewer
101 * @param annotationAccess the annotation access
102 */
103 public ProjectionSummary(ProjectionViewer projectionViewer, IAnnotationAccess annotationAccess) {
104 super();
105 fProjectionViewer= projectionViewer;
106 fAnnotationAccess= annotationAccess;
107 }
108
109 /**
110 * Adds the given annotation type. For now on, annotations of that type are
111 * also reflected in their enclosing collapsed regions.
112 *
113 * @param annotationType the annotation type to add
114 */
115 public void addAnnotationType(String annotationType) {
116 synchronized(fLock) {
117 if (fConfiguredAnnotationTypes is null) {
118 fConfiguredAnnotationTypes= new ArrayList();
119 fConfiguredAnnotationTypes.add(annotationType);
120 } else if (!fConfiguredAnnotationTypes.contains(annotationType))
121 fConfiguredAnnotationTypes.add(annotationType);
122 }
123 }
124
125 /**
126 * Removes the given annotation. Annotation of that type are no
127 * longer reflected in their enclosing collapsed region.
128 *
129 * @param annotationType the annotation type to remove
130 */
131 public void removeAnnotationType(String annotationType) {
132 synchronized (fLock) {
133 if (fConfiguredAnnotationTypes !is null) {
134 fConfiguredAnnotationTypes.remove(annotationType);
135 if (fConfiguredAnnotationTypes.size() is 0)
136 fConfiguredAnnotationTypes= null;
137 }
138 }
139 }
140
141 /**
142 * Forces an updated of the annotation summary.
143 */
144 public void updateSummaries() {
145 synchronized (fLock) {
146 if (fConfiguredAnnotationTypes !is null) {
147 if (fSummarizer is null)
148 fSummarizer= new Summarizer();
149 fSummarizer.reset();
150 }
151 }
152 }
153
154 private void internalUpdateSummaries(IProgressMonitor monitor) {
155
156 Object previousLockObject= null;
157 fAnnotationModel= fProjectionViewer.getVisualAnnotationModel();
158 if (fAnnotationModel is null)
159 return;
160
161 try {
162
163
164 IDocument document= fProjectionViewer.getDocument();
165 if (document instanceof ISynchronizable && fAnnotationModel instanceof ISynchronizable) {
166 ISynchronizable sync= (ISynchronizable) fAnnotationModel;
167 previousLockObject= sync.getLockObject();
168 sync.setLockObject(((ISynchronizable) document).getLockObject());
169 }
170
171
172 removeSummaries(monitor);
173
174 if (isCanceled(monitor))
175 return;
176
177 createSummaries(monitor);
178
179 } finally {
180
181 if (fAnnotationModel instanceof ISynchronizable) {
182 ISynchronizable sync= (ISynchronizable) fAnnotationModel;
183 sync.setLockObject(previousLockObject);
184 }
185 fAnnotationModel= null;
186
187 }
188 }
189
190 private bool isCanceled(IProgressMonitor monitor) {
191 return monitor !is null && monitor.isCanceled();
192 }
193
194 private void removeSummaries(IProgressMonitor monitor) {
195 IAnnotationModelExtension extension= null;
196 List bags= null;
197
198 if (fAnnotationModel instanceof IAnnotationModelExtension) {
199 extension= (IAnnotationModelExtension) fAnnotationModel;
200 bags= new ArrayList();
201 }
202
203 Iterator e= fAnnotationModel.getAnnotationIterator();
204 while (e.hasNext()) {
205 Annotation annotation= (Annotation) e.next();
206 if (annotation instanceof AnnotationBag) {
207 if (bags is null)
208 fAnnotationModel.removeAnnotation(annotation);
209 else
210 bags.add(annotation);
211 }
212
213 if (isCanceled(monitor))
214 return;
215 }
216
217 if (bags !is null && bags.size() > 0) {
218 Annotation[] deletions= new Annotation[bags.size()];
219 bags.toArray(deletions);
220 if (!isCanceled(monitor))
221 extension.replaceAnnotations(deletions, null);
222 }
223 }
224
225 private void createSummaries(IProgressMonitor monitor) {
226 ProjectionAnnotationModel model= fProjectionViewer.getProjectionAnnotationModel();
227 if (model is null)
228 return;
229
230 Map additions= new HashMap();
231
232 Iterator e= model.getAnnotationIterator();
233 while (e.hasNext()) {
234 ProjectionAnnotation projection= (ProjectionAnnotation) e.next();
235 if (projection.isCollapsed()) {
236 Position position= model.getPosition(projection);
237 if (position !is null) {
238 IRegion[] summaryRegions= fProjectionViewer.computeCollapsedRegions(position);
239 if (summaryRegions !is null) {
240 Position summaryAnchor= fProjectionViewer.computeCollapsedRegionAnchor(position);
241 if (summaryAnchor !is null)
242 createSummary(additions, summaryRegions, summaryAnchor);
243 }
244 }
245 }
246
247 if (isCanceled(monitor))
248 return;
249 }
250
251 if (additions.size() > 0) {
252 if (fAnnotationModel instanceof IAnnotationModelExtension) {
253 IAnnotationModelExtension extension= (IAnnotationModelExtension) fAnnotationModel;
254 if (!isCanceled(monitor))
255 extension.replaceAnnotations(null, additions);
256 } else {
257 Iterator e1= additions.keySet().iterator();
258 while (e1.hasNext()) {
259 AnnotationBag bag= (AnnotationBag) e1.next();
260 Position position= (Position) additions.get(bag);
261 if (isCanceled(monitor))
262 return;
263 fAnnotationModel.addAnnotation(bag, position);
264 }
265 }
266 }
267 }
268
269 private void createSummary(Map additions, IRegion[] summaryRegions, Position summaryAnchor) {
270
271 int size= 0;
272 Map map= null;
273
274 synchronized (fLock) {
275 if (fConfiguredAnnotationTypes !is null) {
276 size= fConfiguredAnnotationTypes.size();
277 map= new HashMap();
278 for (int i= 0; i < size; i++) {
279 String type= (String) fConfiguredAnnotationTypes.get(i);
280 map.put(type, new AnnotationBag(type));
281 }
282 }
283 }
284
285 if (map is null)
286 return;
287
288 IAnnotationModel model= fProjectionViewer.getAnnotationModel();
289 if (model is null)
290 return;
291 Iterator e= model.getAnnotationIterator();
292 while (e.hasNext()) {
293 Annotation annotation= (Annotation) e.next();
294 AnnotationBag bag= findBagForType(map, annotation.getType());
295 if (bag !is null) {
296 Position position= model.getPosition(annotation);
297 if (includes(summaryRegions, position))
298 bag.add(annotation);
299 }
300 }
301
302 for (int i= 0; i < size; i++) {
303 AnnotationBag bag= (AnnotationBag) map.get(fConfiguredAnnotationTypes.get(i));
304 if (!bag.isEmpty())
305 additions.put(bag, new Position(summaryAnchor.getOffset(), summaryAnchor.getLength()));
306 }
307 }
308
309 private AnnotationBag findBagForType(Map bagMap, String annotationType) {
310 AnnotationBag bag= (AnnotationBag) bagMap.get(annotationType);
311 if (bag is null && fAnnotationAccess instanceof IAnnotationAccessExtension) {
312 IAnnotationAccessExtension extension= (IAnnotationAccessExtension) fAnnotationAccess;
313 Object[] superTypes= extension.getSupertypes(annotationType);
314 for (int i= 0; i < superTypes.length && bag is null; i++) {
315 bag= (AnnotationBag) bagMap.get(superTypes[i]);
316 }
317 }
318 return bag;
319 }
320
321 private bool includes(IRegion[] regions, Position position) {
322 for (int i= 0; i < regions.length; i++) {
323 IRegion region= regions[i];
324 if (position !is null && !position.isDeleted()
325 && region.getOffset() <= position.getOffset() && position.getOffset() + position.getLength() <= region.getOffset() + region.getLength())
326 return true;
327 }
328 return false;
329 }
330 }