net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/phpeditor/ProblemPainter.java

   1 /**********************************************************************
   2 Copyright (c) 2000, 2002 IBM Corp. 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 implementation
  10 **********************************************************************/
  11
  12 package net.sourceforge.phpeclipse.phpeditor;
  13
  14
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.HashSet;
  18 import java.util.Iterator;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Set;
  22
  23 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  24
  25 import org.eclipse.jface.text.BadLocationException;
  26 import org.eclipse.jface.text.IDocument;
  27 import org.eclipse.jface.text.IRegion;
  28 import org.eclipse.jface.text.ITextViewerExtension5;
  29 import org.eclipse.jface.text.Position;
  30 import org.eclipse.jface.text.Region;
  31 import org.eclipse.jface.text.source.Annotation;
  32 import org.eclipse.jface.text.source.IAnnotationModel;
  33 import org.eclipse.jface.text.source.IAnnotationModelListener;
  34 import org.eclipse.jface.text.source.ISourceViewer;
  35 import org.eclipse.swt.custom.StyledText;
  36 import org.eclipse.swt.events.PaintEvent;
  37 import org.eclipse.swt.events.PaintListener;
  38 import org.eclipse.swt.graphics.Color;
  39 import org.eclipse.swt.graphics.GC;
  40 import org.eclipse.swt.graphics.Point;
  41 import org.eclipse.swt.widgets.Display;
  42 import org.eclipse.ui.texteditor.IDocumentProvider;
  43 import org.eclipse.ui.texteditor.ITextEditor;
  44
  45 /**
  46  * Highlights the temporary problems.
  47  */
  48 public class ProblemPainter implements IPainter, PaintListener, IAnnotationModelListener {
  49
  50         private static class ProblemPosition {
  51                 Position fPosition;
  52                 Color fColor;
  53                 boolean fMultiLine;
  54         };
  55
  56         private boolean fIsActive= false;
  57         private boolean fIsPainting= false;
  58         private boolean fIsSettingModel= false;
  59
  60         private ITextEditor fTextEditor;
  61         private ISourceViewer fSourceViewer;
  62         private StyledText fTextWidget;
  63         private IAnnotationModel fModel;
  64         private List fProblemPositions= new ArrayList();
  65
  66         private Map fColorTable= new HashMap();
  67         private Set fAnnotationSet= new HashSet();
  68
  69
  70
  71         public ProblemPainter(ITextEditor textEditor, ISourceViewer sourceViewer) {
  72                 fTextEditor= textEditor;
  73                 fSourceViewer= sourceViewer;
  74                 fTextWidget= sourceViewer.getTextWidget();
  75         }
  76
  77         private boolean hasProblems() {
  78                 return !fProblemPositions.isEmpty();
  79         }
  80
  81         private void enablePainting() {
  82                 if (!fIsPainting && hasProblems()) {
  83                         fIsPainting= true;
  84                         fTextWidget.addPaintListener(this);
  85                         handleDrawRequest(null);
  86                 }
  87         }
  88
  89         private void disablePainting(boolean redraw) {
  90                 if (fIsPainting) {
  91                         fIsPainting= false;
  92                         fTextWidget.removePaintListener(this);
  93                         if (redraw && hasProblems())
  94                                 handleDrawRequest(null);
  95                 }
  96         }
  97
  98         private void setModel(IAnnotationModel model) {
  99                 if (fModel != model) {
 100                         if (fModel != null)
 101                                 fModel.removeAnnotationModelListener(this);
 102                         fModel= model;
 103                         if (fModel != null) {
 104                                 try {
 105                                         fIsSettingModel= true;
 106                                         fModel.addAnnotationModelListener(this);
 107                                 } finally {
 108                                         fIsSettingModel= false;
 109                                 }
 110                         }
 111                 }
 112         }
 113
 114         private void catchupWithModel() {
 115                 if (fProblemPositions != null) {
 116                         fProblemPositions.clear();
 117                         if (fModel != null) {
 118
 119                                 Iterator e= new ProblemAnnotationIterator(fModel, true);
 120                                 while (e.hasNext()) {
 121                                         IProblemAnnotation pa= (IProblemAnnotation) e.next();
 122                                         Annotation a= (Annotation) pa;
 123
 124                                         Color color= null;
 125                                         AnnotationType type= pa.getAnnotationType();
 126                                         if (fAnnotationSet.contains(type))
 127                                                 color= (Color) fColorTable.get(type);
 128
 129                                         if (color != null) {
 130                                                 ProblemPosition pp= new ProblemPosition();
 131                                                 pp.fPosition= fModel.getPosition(a);
 132                                                 pp.fColor= color;
 133                                                 pp.fMultiLine= true;
 134                                                 fProblemPositions.add(pp);
 135                                         }
 136                                 }
 137                         }
 138                 }
 139         }
 140
 141         private void updatePainting() {
 142                 disablePainting(true);
 143                 catchupWithModel();
 144                 enablePainting();
 145         }
 146
 147         /*
 148          * @see IAnnotationModelListener#modelChanged(IAnnotationModel)
 149          */
 150         public void modelChanged(final IAnnotationModel model) {
 151                 if (fTextWidget != null && !fTextWidget.isDisposed()) {
 152                         if (fIsSettingModel) {
 153                                 // inside the ui thread -> no need for posting
 154                                 updatePainting();
 155                         } else {
 156                                 Display d= fTextWidget.getDisplay();
 157                                 if (d != null) {
 158                                         d.asyncExec(new Runnable() {
 159                                                 public void run() {
 160                                                         if (fTextWidget != null && !fTextWidget.isDisposed())
 161                                                                 updatePainting();
 162                                                 }
 163                                         });
 164                                 }
 165                         }
 166                 }
 167         }
 168
 169         public void setColor(AnnotationType annotationType, Color color) {
 170                 if (color != null)
 171                         fColorTable.put(annotationType, color);
 172                 else
 173                         fColorTable.remove(annotationType);
 174         }
 175
 176         public void paintAnnotations(AnnotationType annotationType, boolean paint) {
 177                 if (paint)
 178                         fAnnotationSet.add(annotationType);
 179                 else
 180                         fAnnotationSet.remove(annotationType);
 181         }
 182
 183         public boolean isPaintingAnnotations() {
 184                 return !fAnnotationSet.isEmpty();
 185         }
 186
 187         /*
 188          * @see IPainter#dispose()
 189          */
 190         public void dispose() {
 191
 192                 if (fColorTable != null)
 193                         fColorTable.clear();
 194                 fColorTable= null;
 195
 196                 if (fAnnotationSet != null)
 197                         fAnnotationSet.clear();
 198                 fAnnotationSet= null;
 199
 200                 fTextWidget= null;
 201                 fModel= null;
 202                 fProblemPositions= null;
 203         }
 204
 205         /*
 206          * Returns the document offset of the upper left corner of the widgets viewport,
 207          * possibly including partially visible lines.
 208          */
 209         private int getInclusiveTopIndexStartOffset() {
 210
 211                 if (fTextWidget != null && !fTextWidget.isDisposed()) {
 212                         int top= fSourceViewer.getTopIndex();
 213                         if ((fTextWidget.getTopPixel() % fTextWidget.getLineHeight()) != 0)
 214                                 top--;
 215                         try {
 216                                 IDocument document= fSourceViewer.getDocument();
 217                                 return document.getLineOffset(top);
 218                         } catch (BadLocationException ex) {
 219                         }
 220                 }
 221
 222                 return -1;
 223         }
 224
 225         /*
 226          * @see PaintListener#paintControl(PaintEvent)
 227          */
 228         public void paintControl(PaintEvent event) {
 229                 if (fTextWidget != null)
 230                         handleDrawRequest(event.gc);
 231         }
 232
 233         private void handleDrawRequest(GC gc) {
 234
 235                 int vOffset= getInclusiveTopIndexStartOffset();
 236                 // http://bugs.eclipse.org/bugs/show_bug.cgi?id=17147
 237                 int vLength= fSourceViewer.getBottomIndexEndOffset() + 1;
 238
 239                 for (Iterator e = fProblemPositions.iterator(); e.hasNext();) {
 240                         ProblemPosition pp = (ProblemPosition) e.next();
 241                         Position p= pp.fPosition;
 242                         if (p.overlapsWith(vOffset, vLength)) {
 243
 244                                 if (!pp.fMultiLine) {
 245
 246                                         IRegion widgetRange= getWidgetRange(p);
 247                                         if (widgetRange != null)
 248                                                 draw(gc, widgetRange.getOffset(), widgetRange.getLength(), pp.fColor);
 249
 250                                 } else {
 251
 252                                         IDocument document= fSourceViewer.getDocument();
 253                                         try {
 254
 255                                                 int startLine= document.getLineOfOffset(p.getOffset());
 256                                                 int lastInclusive= Math.max(p.getOffset(), p.getOffset() + p.getLength() - 1);
 257                                                 int endLine= document.getLineOfOffset(lastInclusive);
 258
 259                                                 for (int i= startLine; i <= endLine; i++) {
 260                                                         IRegion line= document.getLineInformation(i);
 261                                                         int paintStart= Math.max(line.getOffset(), p.getOffset());
 262                                                         int paintEnd= Math.min(line.getOffset() + line.getLength(), p.getOffset() + p.getLength());
 263                                                         if (paintEnd > paintStart) {
 264                                                                 // otherwise inside a line delimiter
 265                                                                 IRegion widgetRange= getWidgetRange(new Position(paintStart, paintEnd - paintStart));
 266                                                                 if (widgetRange != null)
 267                                                                         draw(gc, widgetRange.getOffset(), widgetRange.getLength(), pp.fColor);
 268                                                         }
 269                                                 }
 270
 271                                         } catch (BadLocationException x) {
 272                                         }
 273                                 }
 274                         }
 275                 }
 276         }
 277
 278         private IRegion getWidgetRange(Position p) {
 279                 if (fSourceViewer instanceof ITextViewerExtension5) {
 280                         ITextViewerExtension5 extension= (ITextViewerExtension5) fSourceViewer;
 281                         return extension.modelRange2WidgetRange(new Region(p.getOffset(), p.getLength()));
 282
 283                 } else {
 284
 285                         IRegion region= fSourceViewer.getVisibleRegion();
 286                         int offset= region.getOffset();
 287                         int length= region.getLength();
 288
 289                         if (p.overlapsWith(offset , length)) {
 290                                 int p1= Math.max(offset, p.getOffset());
 291                                 int p2= Math.min(offset + length, p.getOffset() + p.getLength());
 292                                 return new Region(p1 - offset, p2 - p1);
 293                         }
 294                 }
 295
 296                 return null;
 297         }
 298
 299         private int[] computePolyline(Point left, Point right, int height) {
 300
 301                 final int WIDTH= 4; // must be even
 302                 final int HEIGHT= 2; // can be any number
 303 //              final int MINPEEKS= 2; // minimal number of peeks
 304
 305                 int peeks= (right.x - left.x) / WIDTH;
 306 //              if (peeks < MINPEEKS) {
 307 //                      int missing= (MINPEEKS - peeks) * WIDTH;
 308 //                      left.x= Math.max(0, left.x - missing/2);
 309 //                      peeks= MINPEEKS;
 310 //              }
 311
 312                 int leftX= left.x;
 313
 314                 // compute (number of point) * 2
 315                 int length= ((2 * peeks) + 1) * 2;
 316                 if (length < 0)
 317                         return new int[0];
 318
 319                 int[] coordinates= new int[length];
 320
 321                 // cache peeks' y-coordinates
 322                 int bottom= left.y + height - 1;
 323                 int top= bottom - HEIGHT;
 324
 325                 // populate array with peek coordinates
 326                 for (int i= 0; i < peeks; i++) {
 327                         int index= 4 * i;
 328                         coordinates[index]= leftX + (WIDTH * i);
 329                         coordinates[index+1]= bottom;
 330                         coordinates[index+2]= coordinates[index] + WIDTH/2;
 331                         coordinates[index+3]= top;
 332                 }
 333
 334                 // the last down flank is missing
 335                 coordinates[length-2]= left.x + (WIDTH * peeks);
 336                 coordinates[length-1]= bottom;
 337
 338                 return coordinates;
 339         }
 340
 341         private void draw(GC gc, int offset, int length, Color color) {
 342                 if (gc != null) {
 343
 344                         Point left= fTextWidget.getLocationAtOffset(offset);
 345                         Point right= fTextWidget.getLocationAtOffset(offset + length);
 346
 347                         gc.setForeground(color);
 348                         int[] polyline= computePolyline(left, right, gc.getFontMetrics().getHeight());
 349                         gc.drawPolyline(polyline);
 350
 351                 } else {
 352                         fTextWidget.redrawRange(offset, length, true);
 353                 }
 354         }
 355
 356         /*
 357          * @see IPainter#deactivate(boolean)
 358          */
 359         public void deactivate(boolean redraw) {
 360                 if (fIsActive) {
 361                         fIsActive= false;
 362                         disablePainting(redraw);
 363                         setModel(null);
 364                         catchupWithModel();
 365                 }
 366         }
 367
 368         /*
 369          * @see IPainter#paint(int)
 370          */
 371         public void paint(int reason) {
 372                 if (!fIsActive) {
 373                         fIsActive= true;
 374                         IDocumentProvider provider= PHPeclipsePlugin.getDefault().getCompilationUnitDocumentProvider();
 375                         setModel(provider.getAnnotationModel(fTextEditor.getEditorInput()));
 376                 } else if (CONFIGURATION == reason || INTERNAL == reason)
 377                         updatePainting();
 378         }
 379
 380         /*
 381          * @see IPainter#setPositionManager(IPositionManager)
 382          */
 383         public void setPositionManager(IPositionManager manager) {
 384         }
 385 }