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