net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/phpeditor/OverviewRuler.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 import java.util.ArrayList;
  15 import java.util.Collections;
  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.phpdt.ui.text.JavaTextTools;
  24 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  25
  26 import org.eclipse.jface.text.BadLocationException;
  27 import org.eclipse.jface.text.IDocument;
  28 import org.eclipse.jface.text.IRegion;
  29 import org.eclipse.jface.text.ITextListener;
  30 import org.eclipse.jface.text.ITextViewer;
  31 import org.eclipse.jface.text.ITextViewerExtension3;
  32 import org.eclipse.jface.text.Position;
  33 import org.eclipse.jface.text.Region;
  34 import org.eclipse.jface.text.TextEvent;
  35 import org.eclipse.jface.text.source.Annotation;
  36 import org.eclipse.jface.text.source.IAnnotationModel;
  37 import org.eclipse.jface.text.source.IAnnotationModelListener;
  38 import org.eclipse.jface.text.source.IVerticalRulerInfo;
  39 import org.eclipse.swt.SWT;
  40 import org.eclipse.swt.custom.StyledText;
  41 import org.eclipse.swt.events.DisposeEvent;
  42 import org.eclipse.swt.events.DisposeListener;
  43 import org.eclipse.swt.events.MouseAdapter;
  44 import org.eclipse.swt.events.MouseEvent;
  45 import org.eclipse.swt.events.MouseMoveListener;
  46 import org.eclipse.swt.events.PaintEvent;
  47 import org.eclipse.swt.events.PaintListener;
  48 import org.eclipse.swt.graphics.Color;
  49 import org.eclipse.swt.graphics.Cursor;
  50 import org.eclipse.swt.graphics.GC;
  51 import org.eclipse.swt.graphics.Image;
  52 import org.eclipse.swt.graphics.Point;
  53 import org.eclipse.swt.graphics.RGB;
  54 import org.eclipse.swt.graphics.Rectangle;
  55 import org.eclipse.swt.widgets.Canvas;
  56 import org.eclipse.swt.widgets.Composite;
  57 import org.eclipse.swt.widgets.Control;
  58 import org.eclipse.swt.widgets.Display;
  59
  60 /**
  61  *
  62  */
  63 public class OverviewRuler implements IVerticalRulerInfo {
  64
  65   /**
  66    * Internal listener class.
  67    */
  68   class InternalListener implements ITextListener, IAnnotationModelListener {
  69
  70     /*
  71      * @see ITextListener#textChanged
  72      */
  73     public void textChanged(TextEvent e) {
  74       if (fTextViewer != null && e.getDocumentEvent() == null && e.getViewerRedrawState()) {
  75         // handle only changes of visible document
  76         redraw();
  77       }
  78     }
  79
  80     /*
  81      * @see IAnnotationModelListener#modelChanged(IAnnotationModel)
  82      */
  83     public void modelChanged(IAnnotationModel model) {
  84       update();
  85     }
  86   }
  87
  88   /**
  89    * Filters problems based on their types.
  90    */
  91   class FilterIterator implements Iterator {
  92
  93     private final static int IGNORE = 0;
  94     private final static int TEMPORARY = 1;
  95     private final static int PERSISTENT = 2;
  96
  97     private Iterator fIterator;
  98     private AnnotationType fType;
  99     private IProblemAnnotation fNext;
 100     private int fTemporary;
 101
 102     public FilterIterator(AnnotationType type) {
 103       this(type, IGNORE);
 104     }
 105
 106     public FilterIterator(AnnotationType type, boolean temporary) {
 107       this(type, temporary ? TEMPORARY : PERSISTENT);
 108     }
 109
 110     private FilterIterator(AnnotationType type, int temporary) {
 111       fType = type;
 112       fTemporary = temporary;
 113       if (fModel != null) {
 114         fIterator = fModel.getAnnotationIterator();
 115         skip();
 116       }
 117     }
 118
 119     private void skip() {
 120       while (fIterator.hasNext()) {
 121         Object next = fIterator.next();
 122         if (next instanceof IProblemAnnotation) {
 123           fNext = (IProblemAnnotation) next;
 124           AnnotationType type = fNext.getAnnotationType();
 125           if (fType == AnnotationType.ALL || fType == type) {
 126             if (fTemporary == IGNORE)
 127               return;
 128             if (fTemporary == TEMPORARY && fNext.isTemporary())
 129               return;
 130             if (fTemporary == PERSISTENT && !fNext.isTemporary())
 131               return;
 132           }
 133         }
 134       }
 135       fNext = null;
 136     }
 137
 138     /*
 139      * @see Iterator#hasNext()
 140      */
 141     public boolean hasNext() {
 142       return fNext != null;
 143     }
 144     /*
 145      * @see Iterator#next()
 146      */
 147     public Object next() {
 148       try {
 149         return fNext;
 150       } finally {
 151         if (fModel != null)
 152           skip();
 153       }
 154     }
 155     /*
 156      * @see Iterator#remove()
 157      */
 158     public void remove() {
 159       throw new UnsupportedOperationException();
 160     }
 161   };
 162
 163   private static final int INSET = 2;
 164   private static final int PROBLEM_HEIGHT_MIN = 4;
 165   private static boolean PROBLEM_HEIGHT_SCALABLE = false;
 166
 167   /** The model of the overview ruler */
 168   private IAnnotationModel fModel;
 169   /** The view to which this ruler is connected */
 170   private ITextViewer fTextViewer;
 171   /** The ruler's canvas */
 172   private Canvas fCanvas;
 173   /** The drawable for double buffering */
 174   private Image fBuffer;
 175   /** The internal listener */
 176   private InternalListener fInternalListener = new InternalListener();
 177   /** The width of this vertical ruler */
 178   private int fWidth;
 179   /** The hit detection cursor */
 180   private Cursor fHitDetectionCursor;
 181   /** The last cursor */
 182   private Cursor fLastCursor;
 183   /** Cache for the actual scroll position in pixels */
 184   private int fScrollPos;
 185   /** The line of the last mouse button activity */
 186   private int fLastMouseButtonActivityLine = -1;
 187   /** The actual problem height */
 188   private int fProblemHeight = -1;
 189
 190   private Set fAnnotationSet = new HashSet();
 191   private Map fLayers = new HashMap();
 192   private Map fColorTable = new HashMap();
 193
 194   /**
 195    * Constructs a vertical ruler with the given width.
 196    *
 197    * @param width the width of the vertical ruler
 198    */
 199   public OverviewRuler(int width) {
 200     fWidth = width;
 201   }
 202
 203   public Control getControl() {
 204     return fCanvas;
 205   }
 206
 207   public int getWidth() {
 208     return fWidth;
 209   }
 210
 211   public void setModel(IAnnotationModel model) {
 212     if (model != fModel || model != null) {
 213
 214       if (fModel != null)
 215         fModel.removeAnnotationModelListener(fInternalListener);
 216
 217       fModel = model;
 218
 219       if (fModel != null)
 220         fModel.addAnnotationModelListener(fInternalListener);
 221
 222       update();
 223     }
 224   }
 225
 226   public Control createControl(Composite parent, ITextViewer textViewer) {
 227
 228     fTextViewer = textViewer;
 229
 230     fHitDetectionCursor = new Cursor(parent.getDisplay(), SWT.CURSOR_HAND);
 231     fCanvas = new Canvas(parent, SWT.NO_BACKGROUND);
 232
 233     fCanvas.addPaintListener(new PaintListener() {
 234       public void paintControl(PaintEvent event) {
 235         if (fTextViewer != null)
 236           doubleBufferPaint(event.gc);
 237       }
 238     });
 239
 240     fCanvas.addDisposeListener(new DisposeListener() {
 241       public void widgetDisposed(DisposeEvent event) {
 242         handleDispose();
 243         fTextViewer = null;
 244       }
 245     });
 246
 247     fCanvas.addMouseListener(new MouseAdapter() {
 248       public void mouseDown(MouseEvent event) {
 249         handleMouseDown(event);
 250       }
 251     });
 252
 253     fCanvas.addMouseMoveListener(new MouseMoveListener() {
 254       public void mouseMove(MouseEvent event) {
 255         handleMouseMove(event);
 256       }
 257     });
 258
 259     if (fTextViewer != null)
 260       fTextViewer.addTextListener(fInternalListener);
 261
 262     return fCanvas;
 263   }
 264
 265   /**
 266    * Disposes the ruler's resources.
 267    */
 268   private void handleDispose() {
 269
 270     if (fTextViewer != null) {
 271       fTextViewer.removeTextListener(fInternalListener);
 272       fTextViewer = null;
 273     }
 274
 275     if (fModel != null)
 276       fModel.removeAnnotationModelListener(fInternalListener);
 277
 278     if (fBuffer != null) {
 279       fBuffer.dispose();
 280       fBuffer = null;
 281     }
 282
 283     if (fHitDetectionCursor != null) {
 284       fHitDetectionCursor.dispose();
 285       fHitDetectionCursor = null;
 286     }
 287
 288     fAnnotationSet.clear();
 289     fLayers.clear();
 290     fColorTable.clear();
 291   }
 292
 293   /**
 294    * Double buffer drawing.
 295    */
 296   private void doubleBufferPaint(GC dest) {
 297
 298     Point size = fCanvas.getSize();
 299
 300     if (size.x <= 0 || size.y <= 0)
 301       return;
 302
 303     if (fBuffer != null) {
 304       Rectangle r = fBuffer.getBounds();
 305       if (r.width != size.x || r.height != size.y) {
 306         fBuffer.dispose();
 307         fBuffer = null;
 308       }
 309     }
 310     if (fBuffer == null)
 311       fBuffer = new Image(fCanvas.getDisplay(), size.x, size.y);
 312
 313     GC gc = new GC(fBuffer);
 314     try {
 315       gc.setBackground(fCanvas.getBackground());
 316       gc.fillRectangle(0, 0, size.x, size.y);
 317
 318       if (fTextViewer instanceof ITextViewerExtension3)
 319         doPaint1(gc);
 320       else
 321         doPaint(gc);
 322
 323     } finally {
 324       gc.dispose();
 325     }
 326
 327     dest.drawImage(fBuffer, 0, 0);
 328   }
 329
 330   private void doPaint(GC gc) {
 331
 332     if (fTextViewer == null)
 333       return;
 334
 335     Rectangle r = new Rectangle(0, 0, 0, 0);
 336     int yy, hh = PROBLEM_HEIGHT_MIN;
 337
 338     IDocument document = fTextViewer.getDocument();
 339     IRegion visible = fTextViewer.getVisibleRegion();
 340
 341     StyledText textWidget = fTextViewer.getTextWidget();
 342     int maxLines = textWidget.getLineCount();
 343     fScrollPos = textWidget.getTopPixel();
 344
 345     Point size = fCanvas.getSize();
 346     int writable = maxLines * textWidget.getLineHeight();
 347     if (size.y > writable)
 348       size.y = writable;
 349
 350     List indices = new ArrayList(fLayers.keySet());
 351     Collections.sort(indices);
 352
 353     for (Iterator iterator = indices.iterator(); iterator.hasNext();) {
 354       Object layer = iterator.next();
 355       AnnotationType annotationType = (AnnotationType) fLayers.get(layer);
 356
 357       if (skip(annotationType))
 358         continue;
 359
 360       boolean[] temporary = new boolean[] { false, true };
 361       for (int t = 0; t < temporary.length; t++) {
 362
 363         Iterator e = new FilterIterator(annotationType, temporary[t]);
 364         Color fill = getFillColor(annotationType, temporary[t]);
 365         Color stroke = getStrokeColor(annotationType, temporary[t]);
 366
 367         for (int i = 0; e.hasNext(); i++) {
 368
 369           Annotation a = (Annotation) e.next();
 370           Position p = fModel.getPosition(a);
 371
 372           if (p == null || !p.overlapsWith(visible.getOffset(), visible.getLength()))
 373             continue;
 374
 375           int problemOffset = Math.max(p.getOffset(), visible.getOffset());
 376           int problemEnd = Math.min(p.getOffset() + p.getLength(), visible.getOffset() + visible.getLength());
 377           int problemLength = problemEnd - problemOffset;
 378
 379           try {
 380             if (PROBLEM_HEIGHT_SCALABLE) {
 381               int numbersOfLines = document.getNumberOfLines(problemOffset, problemLength);
 382               hh = (numbersOfLines * size.y) / maxLines;
 383               if (hh < PROBLEM_HEIGHT_MIN)
 384                 hh = PROBLEM_HEIGHT_MIN;
 385             }
 386             fProblemHeight = hh;
 387
 388             int startLine = textWidget.getLineAtOffset(problemOffset - visible.getOffset());
 389             yy = Math.min((startLine * size.y) / maxLines, size.y - hh);
 390
 391             if (fill != null) {
 392               gc.setBackground(fill);
 393               gc.fillRectangle(INSET, yy, size.x - (2 * INSET), hh);
 394             }
 395
 396             if (stroke != null) {
 397               gc.setForeground(stroke);
 398               r.x = INSET;
 399               r.y = yy;
 400               r.width = size.x - (2 * INSET) - 1;
 401               r.height = hh;
 402               gc.setLineWidth(1);
 403               gc.drawRectangle(r);
 404             }
 405           } catch (BadLocationException x) {
 406           }
 407         }
 408       }
 409     }
 410   }
 411
 412   private void doPaint1(GC gc) {
 413
 414     if (fTextViewer == null)
 415       return;
 416
 417     Rectangle r = new Rectangle(0, 0, 0, 0);
 418     int yy, hh = PROBLEM_HEIGHT_MIN;
 419
 420     ITextViewerExtension3 extension = (ITextViewerExtension3) fTextViewer;
 421     IDocument document = fTextViewer.getDocument();
 422     StyledText textWidget = fTextViewer.getTextWidget();
 423     fScrollPos = textWidget.getTopPixel();
 424
 425     int maxLines = textWidget.getLineCount();
 426     Point size = fCanvas.getSize();
 427     int writable = maxLines * textWidget.getLineHeight();
 428     if (size.y > writable)
 429       size.y = writable;
 430
 431     List indices = new ArrayList(fLayers.keySet());
 432     Collections.sort(indices);
 433
 434     for (Iterator iterator = indices.iterator(); iterator.hasNext();) {
 435       Object layer = iterator.next();
 436       AnnotationType annotationType = (AnnotationType) fLayers.get(layer);
 437
 438       if (skip(annotationType))
 439         continue;
 440
 441       boolean[] temporary = new boolean[] { false, true };
 442       for (int t = 0; t < temporary.length; t++) {
 443
 444         Iterator e = new FilterIterator(annotationType, temporary[t]);
 445         Color fill = getFillColor(annotationType, temporary[t]);
 446         Color stroke = getStrokeColor(annotationType, temporary[t]);
 447
 448         for (int i = 0; e.hasNext(); i++) {
 449
 450           Annotation a = (Annotation) e.next();
 451           Position p = fModel.getPosition(a);
 452
 453           if (p == null)
 454             continue;
 455
 456           IRegion widgetRegion = extension.modelRange2WidgetRange(new Region(p.getOffset(), p.getLength()));
 457           if (widgetRegion == null)
 458             continue;
 459
 460           try {
 461             if (PROBLEM_HEIGHT_SCALABLE) {
 462               int numbersOfLines = document.getNumberOfLines(p.getOffset(), p.getLength());
 463               hh = (numbersOfLines * size.y) / maxLines;
 464               if (hh < PROBLEM_HEIGHT_MIN)
 465                 hh = PROBLEM_HEIGHT_MIN;
 466             }
 467             fProblemHeight = hh;
 468
 469             int startLine = textWidget.getLineAtOffset(widgetRegion.getOffset());
 470             yy = Math.min((startLine * size.y) / maxLines, size.y - hh);
 471
 472             if (fill != null) {
 473               gc.setBackground(fill);
 474               gc.fillRectangle(INSET, yy, size.x - (2 * INSET), hh);
 475             }
 476
 477             if (stroke != null) {
 478               gc.setForeground(stroke);
 479               r.x = INSET;
 480               r.y = yy;
 481               r.width = size.x - (2 * INSET) - 1;
 482               r.height = hh;
 483               gc.setLineWidth(1);
 484               gc.drawRectangle(r);
 485             }
 486           } catch (BadLocationException x) {
 487           }
 488         }
 489       }
 490     }
 491   }
 492
 493   /**
 494    * Thread-safe implementation.
 495    * Can be called from any thread.
 496    */
 497   public void update() {
 498     if (fCanvas != null && !fCanvas.isDisposed()) {
 499       Display d = fCanvas.getDisplay();
 500       if (d != null) {
 501         d.asyncExec(new Runnable() {
 502           public void run() {
 503             redraw();
 504           }
 505         });
 506       }
 507     }
 508   }
 509
 510   /**
 511    * Redraws the overview ruler.
 512    */
 513   private void redraw() {
 514     if (fCanvas != null && !fCanvas.isDisposed()) {
 515       GC gc = new GC(fCanvas);
 516       doubleBufferPaint(gc);
 517       gc.dispose();
 518     }
 519   }
 520
 521   private int[] toLineNumbers(int y_coordinate) {
 522
 523     StyledText textWidget = fTextViewer.getTextWidget();
 524     int maxLines = textWidget.getContent().getLineCount();
 525
 526     int rulerLength = fCanvas.getSize().y;
 527     int writable = maxLines * textWidget.getLineHeight();
 528
 529     if (rulerLength > writable)
 530       rulerLength = writable;
 531
 532     if (y_coordinate >= writable)
 533       return new int[] { -1, -1 };
 534
 535     int[] lines = new int[2];
 536
 537     int pixel = Math.max(y_coordinate - 1, 0);
 538     lines[0] = (pixel * maxLines) / rulerLength;
 539
 540     pixel = Math.min(rulerLength, y_coordinate + 1);
 541     lines[1] = (pixel * maxLines) / rulerLength;
 542
 543     if (fTextViewer instanceof ITextViewerExtension3) {
 544       ITextViewerExtension3 extension = (ITextViewerExtension3) fTextViewer;
 545       lines[0] = extension.widgetlLine2ModelLine(lines[0]);
 546       lines[1] = extension.widgetlLine2ModelLine(lines[1]);
 547     } else {
 548       try {
 549         IRegion visible = fTextViewer.getVisibleRegion();
 550         int lineNumber = fTextViewer.getDocument().getLineOfOffset(visible.getOffset());
 551         lines[0] += lineNumber;
 552         lines[1] += lineNumber;
 553       } catch (BadLocationException x) {
 554       }
 555     }
 556
 557     return lines;
 558   }
 559
 560   boolean hasAnnotationAt(int y_coordinate) {
 561     return findBestMatchingLineNumber(toLineNumbers(y_coordinate)) != -1;
 562   }
 563
 564   private Position getProblemPositionAt(int[] lineNumbers) {
 565     if (lineNumbers[0] == -1)
 566       return null;
 567
 568     Position found = null;
 569
 570     try {
 571       IDocument d = fTextViewer.getDocument();
 572       IRegion line = d.getLineInformation(lineNumbers[0]);
 573
 574       int start = line.getOffset();
 575
 576       line = d.getLineInformation(lineNumbers[lineNumbers.length - 1]);
 577       int end = line.getOffset() + line.getLength();
 578
 579       Iterator e = new FilterIterator(AnnotationType.ALL);
 580       while (e.hasNext()) {
 581         Annotation a = (Annotation) e.next();
 582         Position p = fModel.getPosition(a);
 583         if (start <= p.getOffset() && p.getOffset() < end) {
 584           if (found == null || p.getOffset() < found.getOffset())
 585             found = p;
 586         }
 587       }
 588
 589     } catch (BadLocationException x) {
 590     }
 591
 592     return found;
 593   }
 594
 595   /**
 596    * Returns the line which best corresponds to one of
 597    * the underlying problem annotations at the given
 598    * y ruler coordinate.
 599    *
 600    * @return the best matching line or <code>-1</code> if no such line can be found
 601    * @since 2.1
 602    */
 603   private int findBestMatchingLineNumber(int[] lineNumbers) {
 604     if (lineNumbers == null || lineNumbers.length < 1)
 605       return -1;
 606
 607     try {
 608       Position pos = getProblemPositionAt(lineNumbers);
 609       if (pos == null)
 610         return -1;
 611       return fTextViewer.getDocument().getLineOfOffset(pos.getOffset());
 612     } catch (BadLocationException ex) {
 613       return -1;
 614     }
 615   }
 616
 617   private void handleMouseDown(MouseEvent event) {
 618     if (fTextViewer != null) {
 619       int[] lines = toLineNumbers(event.y);
 620       Position p = getProblemPositionAt(lines);
 621       if (p != null) {
 622         fTextViewer.revealRange(p.getOffset(), p.getLength());
 623         fTextViewer.setSelectedRange(p.getOffset(), p.getLength());
 624       }
 625       fTextViewer.getTextWidget().setFocus();
 626     }
 627     fLastMouseButtonActivityLine = toDocumentLineNumber(event.y);
 628   }
 629
 630   private void handleMouseMove(MouseEvent event) {
 631     if (fTextViewer != null) {
 632       int[] lines = toLineNumbers(event.y);
 633       Position p = getProblemPositionAt(lines);
 634       Cursor cursor = (p != null ? fHitDetectionCursor : null);
 635       if (cursor != fLastCursor) {
 636         fCanvas.setCursor(cursor);
 637         fLastCursor = cursor;
 638       }
 639     }
 640   }
 641
 642   private void handleMouseDoubleClick(MouseEvent event) {
 643     fLastMouseButtonActivityLine = toDocumentLineNumber(event.y);
 644   }
 645
 646   public void showAnnotation(AnnotationType annotationType, boolean show) {
 647     if (show)
 648       fAnnotationSet.add(annotationType);
 649     else
 650       fAnnotationSet.remove(annotationType);
 651   }
 652
 653   public void setLayer(AnnotationType annotationType, int layer) {
 654     if (layer >= 0)
 655       fLayers.put(new Integer(layer), annotationType);
 656     else {
 657       Iterator e = fLayers.keySet().iterator();
 658       while (e.hasNext()) {
 659         Object key = e.next();
 660         if (annotationType.equals(fLayers.get(key))) {
 661           fLayers.remove(key);
 662           return;
 663         }
 664       }
 665     }
 666   }
 667
 668   public void setColor(AnnotationType annotationType, Color color) {
 669     if (color != null)
 670       fColorTable.put(annotationType, color);
 671     else
 672       fColorTable.remove(annotationType);
 673   }
 674
 675   private boolean skip(AnnotationType annotationType) {
 676     return !fAnnotationSet.contains(annotationType);
 677   }
 678
 679   private static RGB interpolate(RGB fg, RGB bg, double scale) {
 680     return new RGB(
 681       (int) ((1.0 - scale) * fg.red + scale * bg.red),
 682       (int) ((1.0 - scale) * fg.green + scale * bg.green),
 683       (int) ((1.0 - scale) * fg.blue + scale * bg.blue));
 684   }
 685
 686   private static double greyLevel(RGB rgb) {
 687     if (rgb.red == rgb.green && rgb.green == rgb.blue)
 688       return rgb.red;
 689     return (0.299 * rgb.red + 0.587 * rgb.green + 0.114 * rgb.blue + 0.5);
 690   }
 691
 692   private static boolean isDark(RGB rgb) {
 693     return greyLevel(rgb) > 128;
 694   }
 695
 696   private static Color getColor(RGB rgb) {
 697     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
 698     return textTools.getColorManager().getColor(rgb);
 699   }
 700
 701   private Color getColor(AnnotationType annotationType, double scale) {
 702     Color base = (Color) fColorTable.get(annotationType);
 703     if (base == null)
 704       return null;
 705
 706     RGB baseRGB = base.getRGB();
 707     RGB background = fCanvas.getBackground().getRGB();
 708
 709     boolean darkBase = isDark(baseRGB);
 710     boolean darkBackground = isDark(background);
 711     if (darkBase && darkBackground)
 712       background = new RGB(255, 255, 255);
 713     else if (!darkBase && !darkBackground)
 714       background = new RGB(0, 0, 0);
 715
 716     return getColor(interpolate(baseRGB, background, scale));
 717   }
 718
 719   private Color getStrokeColor(AnnotationType annotationType, boolean temporary) {
 720     return getColor(annotationType, temporary ? 0.5 : 0.2);
 721   }
 722
 723   private Color getFillColor(AnnotationType annotationType, boolean temporary) {
 724     return getColor(annotationType, temporary ? 0.9 : 0.6);
 725   }
 726
 727   /**
 728    * @see IVerticalRulerInfo#getLineOfLastMouseButtonActivity()
 729    * @since 2.1
 730    */
 731   public int getLineOfLastMouseButtonActivity() {
 732     return fLastMouseButtonActivityLine;
 733   }
 734
 735   /**
 736    * @see IVerticalRulerInfo#toDocumentLineNumber(int)
 737    * @since 2.1
 738    */
 739   public int toDocumentLineNumber(int y_coordinate) {
 740
 741     if (fTextViewer == null || y_coordinate == -1)
 742       return -1;
 743
 744     int[] lineNumbers = toLineNumbers(y_coordinate);
 745     int bestLine = findBestMatchingLineNumber(lineNumbers);
 746     if (bestLine == -1 && lineNumbers.length > 0)
 747       return lineNumbers[0];
 748     return bestLine;
 749   }
 750
 751   /**
 752    * Returns the height of the problem rectangle.
 753    *
 754    * @return the height of the problem rectangle
 755    * @since 2.1
 756    */
 757   int getAnnotationHeight() {
 758     return fProblemHeight;
 759   }
 760 }