64905c4c8b63c62a6188d72c1047dec1db7b42a3
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / JavaMarkerAnnotation.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11
12 package net.sourceforge.phpeclipse.phpeditor;
13
14
15 import java.util.Iterator;
16
17 import net.sourceforge.phpdt.internal.ui.PHPUiImages;
18 import net.sourceforge.phpdt.ui.PreferenceConstants;
19 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
20
21 import org.eclipse.core.resources.IMarker;
22 import org.eclipse.core.runtime.CoreException;
23 import org.eclipse.debug.core.model.IBreakpoint;
24 import org.eclipse.debug.ui.DebugUITools;
25 import org.eclipse.debug.ui.IDebugModelPresentation;
26 import org.eclipse.jface.resource.ImageRegistry;
27 import org.eclipse.jface.text.Assert;
28 import org.eclipse.search.ui.SearchUI;
29 import org.eclipse.swt.SWT;
30 import org.eclipse.swt.graphics.Image;
31 import org.eclipse.swt.widgets.Display;
32 import org.eclipse.ui.texteditor.MarkerAnnotation;
33 import org.eclipse.ui.texteditor.MarkerUtilities;
34
35
36
37 public class JavaMarkerAnnotation extends MarkerAnnotation implements IJavaAnnotation {
38         
39         private static final int NO_IMAGE= 0;
40         private static final int ORIGINAL_MARKER_IMAGE= 1;
41         private static final int QUICKFIX_IMAGE= 2;
42         private static final int QUICKFIX_ERROR_IMAGE= 3;
43         private static final int OVERLAY_IMAGE= 4;
44         private static final int GRAY_IMAGE= 5;
45         private static final int BREAKPOINT_IMAGE= 6;
46
47         private static Image fgQuickFixImage;
48         private static Image fgQuickFixErrorImage;
49         private static ImageRegistry fgGrayMarkersImageRegistry;
50         
51         private IDebugModelPresentation fPresentation;
52         private IJavaAnnotation fOverlay;
53         private boolean fNotRelevant= false;
54         private AnnotationType fType;
55         private int fImageType;
56         private boolean fQuickFixIconEnabled;
57         
58         
59         public JavaMarkerAnnotation(IMarker marker) {
60                 super(marker);
61         }
62         
63         /*
64          * @see MarkerAnnotation#getUnknownImageName(IMarker)
65          */
66         protected String getUnknownImageName(IMarker marker) {
67                 return PHPUiImages.IMG_OBJS_GHOST;
68         }
69         
70         /**
71          * Initializes the annotation's icon representation and its drawing layer
72          * based upon the properties of the underlying marker.
73          */
74         protected void initialize() {
75                 fQuickFixIconEnabled= PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_CORRECTION_INDICATION);
76                 fImageType= NO_IMAGE;
77                 IMarker marker= getMarker();
78                 
79                 if (MarkerUtilities.isMarkerType(marker, IBreakpoint.BREAKPOINT_MARKER)) {
80                         
81                         if (fPresentation == null) 
82                                 fPresentation= DebugUITools.newDebugModelPresentation();
83
84                         setImage(null); // see bug 32469
85                         setLayer(4);
86                         fImageType= BREAKPOINT_IMAGE;                                   
87                         
88                         fType= AnnotationType.UNKNOWN;
89                         
90                 } else {
91                         
92                         fType= AnnotationType.UNKNOWN;
93                         if (marker.exists()) {
94                                 try {
95                                         
96                                         if (marker.isSubtypeOf(IMarker.PROBLEM)) {
97                                                 int severity= marker.getAttribute(IMarker.SEVERITY, -1);
98                                                 switch (severity) {
99                                                         case IMarker.SEVERITY_ERROR:
100                                                                 fType= AnnotationType.ERROR;
101                                                                 break;
102                                                         case IMarker.SEVERITY_WARNING:
103                                                                 fType= AnnotationType.WARNING;
104                                                                 break;
105                                                 }
106                                         } else if (marker.isSubtypeOf(IMarker.TASK))
107                                                 fType= AnnotationType.TASK; 
108                                         else if (marker.isSubtypeOf(SearchUI.SEARCH_MARKER)) 
109                                                 fType= AnnotationType.SEARCH;
110                                         else if (marker.isSubtypeOf(IMarker.BOOKMARK))
111                                                 fType= AnnotationType.BOOKMARK;
112                                                 
113                                 } catch(CoreException e) {
114                                         PHPeclipsePlugin.log(e);
115                                 }
116                         }
117                         super.initialize();
118                 }
119         }
120         
121 //      private boolean mustShowQuickFixIcon() {
122 //              return fQuickFixIconEnabled && JavaCorrectionProcessor.hasCorrections(getMarker());
123 //      }
124 //      
125 //      private Image getQuickFixImage() {
126 //              if (fgQuickFixImage == null)
127 //                      fgQuickFixImage= JavaPluginImages.get(JavaPluginImages.IMG_OBJS_FIXABLE_PROBLEM);
128 //              return fgQuickFixImage;
129 //      }
130 //
131 //      private Image getQuickFixErrorImage() {
132 //              if (fgQuickFixErrorImage == null)
133 //                      fgQuickFixErrorImage= JavaPluginImages.get(JavaPluginImages.IMG_OBJS_FIXABLE_ERROR);
134 //              return fgQuickFixErrorImage;
135 //      }
136
137         /*
138          * @see IJavaAnnotation#getMessage()
139          */
140         public String getMessage() {
141                 IMarker marker= getMarker();
142                 if (marker == null || !marker.exists())
143                         return ""; //$NON-NLS-1$
144                 else
145                         return marker.getAttribute(IMarker.MESSAGE, ""); //$NON-NLS-1$
146         }
147
148         /*
149          * @see IJavaAnnotation#isTemporary()
150          */
151         public boolean isTemporary() {
152                 return false;
153         }
154         
155         /*
156          * @see IJavaAnnotation#getArguments()
157          */
158         public String[] getArguments() {
159                 IMarker marker= getMarker();
160 //              if (marker != null && marker.exists() && isProblem())
161 //                      return Util.getProblemArgumentsFromMarker(marker.getAttribute(IJavaModelMarker.ARGUMENTS, "")); //$NON-NLS-1$
162                 return null;
163         }
164
165         /*
166          * @see IJavaAnnotation#getId()
167          */
168         public int getId() {
169                 IMarker marker= getMarker();
170 //              if (marker != null  && marker.exists() && isProblem())
171 //                      return marker.getAttribute(IJavaModelMarker.ID, -1);
172                 return -1;
173         }
174         
175         /*
176          * @see IJavaAnnotation#isProblem()
177          */
178         public boolean isProblem() {
179                 return fType == AnnotationType.WARNING || fType == AnnotationType.ERROR;
180         }
181         
182         /*
183          * @see IJavaAnnotation#isRelevant()
184          */
185         public boolean isRelevant() {
186                 return !fNotRelevant;
187         }
188
189         /**
190          * Overlays this annotation with the given javaAnnotation.
191          * 
192          * @param javaAnnotation annotation that is overlaid by this annotation
193          */
194         public void setOverlay(IJavaAnnotation javaAnnotation) {
195                 if (fOverlay != null)
196                         fOverlay.removeOverlaid(this);
197                         
198                 fOverlay= javaAnnotation;
199                 fNotRelevant= (fNotRelevant || fOverlay != null);
200                 
201                 if (javaAnnotation != null)
202                         javaAnnotation.addOverlaid(this);
203         }
204         
205         /*
206          * @see IJavaAnnotation#hasOverlay()
207          */
208         public boolean hasOverlay() {
209                 return fOverlay != null;
210         }
211         
212         /*
213          * @see MarkerAnnotation#getImage(Display)
214          */
215         public Image getImage(Display display) {
216                 if (fImageType == BREAKPOINT_IMAGE) {
217                         Image result= super.getImage(display);
218                         if (result == null) {
219                                 IMarker marker= getMarker();
220                                 if (marker != null && marker.exists()) {
221                                         result= fPresentation.getImage(getMarker());
222                                         setImage(result);
223                                 }
224                         }                                       
225                         return result;
226                 }
227
228                 int newImageType= NO_IMAGE;
229
230                 if (hasOverlay())
231                         newImageType= OVERLAY_IMAGE;
232                 else if (isRelevant()) {
233 //                      if (mustShowQuickFixIcon()) {
234 //                              if (fType == AnnotationType.ERROR)
235 //                                      newImageType= QUICKFIX_ERROR_IMAGE;
236 //                              else
237 //                                      newImageType= QUICKFIX_IMAGE; 
238 //                      } else
239                                 newImageType= ORIGINAL_MARKER_IMAGE; 
240                 } else
241                         newImageType= GRAY_IMAGE;
242
243                 if (fImageType == newImageType && newImageType != OVERLAY_IMAGE)
244                         // Nothing changed - simply return the current image
245                         return super.getImage(display);
246
247                 Image newImage= null;
248                 switch (newImageType) {
249                         case ORIGINAL_MARKER_IMAGE:
250                                 newImage= null;
251                                 break;
252                         case OVERLAY_IMAGE:
253                                 newImage= fOverlay.getImage(display);
254                                 break;
255 //                      case QUICKFIX_IMAGE:
256 //                              newImage= getQuickFixImage();
257 //                              break;
258 //                      case QUICKFIX_ERROR_IMAGE:
259 //                              newImage= getQuickFixErrorImage();
260 //                              break;
261                         case GRAY_IMAGE:
262                                 if (fImageType != ORIGINAL_MARKER_IMAGE)
263                                         setImage(null);
264                                 Image originalImage= super.getImage(display);
265                                 if (originalImage != null) {
266                                         ImageRegistry imageRegistry= getGrayMarkerImageRegistry(display);
267                                         if (imageRegistry != null) {
268                                                 String key= Integer.toString(originalImage.hashCode());
269                                                 Image grayImage= imageRegistry.get(key);
270                                                 if (grayImage == null) {
271                                                         grayImage= new Image(display, originalImage, SWT.IMAGE_GRAY);
272                                                         imageRegistry.put(key, grayImage);
273                                                 }
274                                                 newImage= grayImage;
275                                         }
276                                 }
277                                 break;
278                         default:
279                                 Assert.isLegal(false);
280                 }
281
282                 fImageType= newImageType;
283                 setImage(newImage);
284                 return super.getImage(display);
285         }
286         
287         private ImageRegistry getGrayMarkerImageRegistry(Display display) {
288                 if (fgGrayMarkersImageRegistry == null)
289                         fgGrayMarkersImageRegistry= new ImageRegistry(display);
290                 return fgGrayMarkersImageRegistry;
291         }
292         
293         /*
294          * @see IJavaAnnotation#addOverlaid(IJavaAnnotation)
295          */
296         public void addOverlaid(IJavaAnnotation annotation) {
297                 // not supported
298         }
299
300         /*
301          * @see IJavaAnnotation#removeOverlaid(IJavaAnnotation)
302          */
303         public void removeOverlaid(IJavaAnnotation annotation) {
304                 // not supported
305         }
306         
307         /*
308          * @see IJavaAnnotation#getOverlaidIterator()
309          */
310         public Iterator getOverlaidIterator() {
311                 // not supported
312                 return null;
313         }
314         
315         /*
316          * @see org.eclipse.jdt.internal.ui.javaeditor.IJavaAnnotation#getAnnotationType()
317          */
318         public AnnotationType getAnnotationType() {
319                 return fType;
320         }
321 }