projects/dwt-addons: dwtx/jface/internal/text/revisions/RevisionPainter.d comparison

comparison dwtx/jface/internal/text/revisions/RevisionPainter.d @ 150:5cf141e43417

...

author	Frank Benoit <benoit@tionex.de>
date	Sun, 24 Aug 2008 23:05:26 +0200
parents	000f9136b8f7
children	f70d9508c95c

comparison

equal deleted inserted replaced

-:b411f1c62131
+:5cf141e43417
 /**
 * A strategy for painting the live annotate colors onto the vertical ruler column. It also manages
 * the revision hover.
 *
 * @since 3.2
 */
 public final class RevisionPainter {
 /** Tells whether this class is in debug mode. */
 private static bool DEBUG= "true".equalsIgnoreCase(Platform.getDebugOption("dwtx.jface.text.source/debug/RevisionRulerColumn")); //$NON-NLS-1$//$NON-NLS-2$
 // RGBs provided by UI Designer
 private static const RGB BY_DATE_START_COLOR= new RGB(199, 134, 57);
 private static const RGB BY_DATE_END_COLOR= new RGB(241, 225, 206);
 /**
 * The annotations created to show a revision in the overview ruler.
 */
 private static final class RevisionAnnotation : Annotation {
 public this(String text) {
 */
 private const Map fFocusColors= new HashMap();
 /**
 * Sets the revision information, which is needed to compute the relative age of a revision.
 *
 * @param info the new revision info, <code>null</code> for none.
 */
 public void setInfo(RevisionInformation info) {
 fRevisions= null;
 fColors.clear();
 fFocusColors.clear();
 if (info is null)
 return;
 List revisions= new ArrayList();
 for (Iterator it= info.getRevisions().iterator(); it.hasNext();) {
 Revision revision= cast(Revision) it.next();
 private int computeAgeIndex(Revision revision) {
 long age= computeAge(revision);
 int index= fRevisions.indexOf(new Long(age));
 return index;
 }
 private RGB getShadedColor(RGB color, float scale, bool focus) {
 Assert.isLegal(scale >= 0.0);
 Assert.isLegal(scale <= 1.0);
 RGB background= getBackground().getRGB();
 return revision.getDate().getTime();
 }
 /**
 * Returns the color for a revision based on relative age and author.
 *
 * @param revision the revision
 * @param focus <code>true</code> to return the focus color
 * @return the color for a revision
 */
 public RGB getColor(Revision revision, bool focus) {
 Map map= focus ? fFocusColors : fColors;
 RGB color= cast(RGB) map.get(revision);
 if (color !is null)
 return color;
 color= adaptColor(revision, focus);
 map.put(revision, color);
 return color;
 }
 }
 * Handles all the mouse interaction in this line number ruler column.
 */
 private class MouseHandler : MouseMoveListener, MouseTrackListener, Listener {
 private RevisionRange fMouseDownRegion;
 private void handleMouseUp(Event e) {
 if (e.button is 1) {
 RevisionRange upRegion= fFocusRange;
 RevisionRange downRegion= fMouseDownRegion;
 fMouseDownRegion= null;
 /**
 * The information control creator.
 */
 private static final class HoverInformationControlCreator : AbstractReusableInformationControlCreator {
 private bool fIsFocusable;
 public this(bool isFocusable) {
 fIsFocusable= isFocusable;
 }
 /*
 */
 public void setInformation(String content) {
 content= addCSSToHTMLFragment(content);
 super.setInformation(content);
 }
 /**
 * Adds a HTML header and CSS info if <code>html</code> is only an HTML fragment (has no
 * &lt;html&gt; section).
 *
 * @param html the html / text produced by a revision
 * @return modified html
 */
 private String addCSSToHTMLFragment(String html) {
 int max= Math.min(100, html.length());
 if (html.substring(0, max).indexOf("<html>") !is -1) //$NON-NLS-1$
 // there is already a header
 return html;
 StringBuffer info= new StringBuffer(512 + html.length());
 HTMLPrinter.insertPageProlog(info, 0, fgStyleSheet);
 info.append(html);
 HTMLPrinter.addPageEpilog(info);
 return info.toString();
 }
 };
 }
 return new DefaultInformationControl(parent, fIsFocusable);
 }
 "strong      { font-weight: bold }\n" + //$NON-NLS-1$
 "em          { font-style: italic }\n" + //$NON-NLS-1$
 "var             { font-style: italic }\n" + //$NON-NLS-1$
 "th          { font-weight: bold }\n" + //$NON-NLS-1$
 ""; //$NON-NLS-1$
 /**
 * The revision hover displays information about the currently selected revision.
 */
 private final class RevisionHover : IAnnotationHover, IAnnotationHoverExtension, IAnnotationHoverExtension2, IInformationProviderExtension2 {
 /*
 * @see dwtx.jface.text.source.IAnnotationHover#getHoverInfo(dwtx.jface.text.source.ISourceViewer,
 *      int)
 */
 public String getHoverInfo(ISourceViewer sourceViewer, int lineNumber) {
 */
 private int fLastWidth= -1;
 /**
 * Creates a new revision painter for a vertical ruler column.
 *
 * @param column the column that will delegate{@link #paint(GC, ILineRange) painting} to the
 *        newly created painter.
 * @param sharedColors a shared colors object to store shaded colors in
 */
 public this(IVerticalRulerColumn column, ISharedTextColors sharedColors) {
 fSharedColors= sharedColors;
 }
 /**
 * Sets the revision information to be drawn and triggers a redraw.
 *
 * @param info the revision information to show, <code>null</code> to draw none
 */
 public void setRevisionInformation(RevisionInformation info) {
 if (fRevisionInfo !is info) {
 fRequiredWidth= -1;
 }
 }
 /**
 * Changes the rendering mode and triggers redrawing if needed.
 *
 * @param renderingMode the rendering mode
 * @since 3.3
 */
 public void setRenderingMode(RenderingMode renderingMode) {
 Assert.isLegal(renderingMode !is null);
 }
 }
 /**
 * Sets the background color.
 *
 * @param background the background color, <code>null</code> for the platform's list
 *        background
 */
 public void setBackground(Color background) {
 fBackground= background;
 }
 /**
 * Sets the parent ruler - the delegating column must call this method as soon as it creates its
 * control.
 *
 * @param parentRuler the parent ruler
 */
 public void setParentRuler(CompositeRuler parentRuler) {
 fParentRuler= parentRuler;
 }
 /**
 * Delegates the painting of the quick diff colors to this painter. The painter will draw the
 * color boxes onto the passed {@link GC} for all model (document) lines in
 * <code>visibleModelLines</code>.
 *
 * @param gc the {@link GC} to draw onto
 * @param visibleLines the lines (in document offsets) that are currently (perhaps only
 *        partially) visible
 */
 public void paint(GC gc, ILineRange visibleLines) {
 string[0]= '.';
 string[1]= ' ';
 }
 fAuthorInset= gc.stringExtent(new String(string)).x;
 }
 // recompute colors (show intense colors if ruler is narrow)
 int width= getWidth();
 if (width !is fLastWidth) {
 fColorTool.setInfo(fRevisionInfo);
 fLastWidth= width;
 }
 // draw change regions
 List/* <RevisionRange> */ranges= getRanges(visibleLines);
 for (Iterator it= ranges.iterator(); it.hasNext();) {
 RevisionRange region= cast(RevisionRange) it.next();
 paintRange(region, gc);
 */
 public void widgetDisposed(DisposeEvent e) {
 handleDispose();
 }
 });
 fRevisionSelectionProvider.install(fViewer);
 }
 /**
 * Returns <code>true</code> if the column is fully connected.
 *
 * @return <code>true</code> if the column is fully connected, false otherwise
 */
 private bool isConnected() {
 return fControl !is null;
 }
 /**
 * Sets the annotation model.
 *
 * @param model the annotation model, possibly <code>null</code>
 * @see IVerticalRulerColumn#setModel(IAnnotationModel)
 */
 public void setModel(IAnnotationModel model) {
 IAnnotationModel diffModel;
 setAnnotationModel(model);
 }
 /**
 * Sets the annotation model.
 *
 * @param model the annotation model.
 */
 private void setAnnotationModel(IAnnotationModel model) {
 if (fAnnotationModel !is model)
 fAnnotationModel= model;
 }
 /**
 * Sets the line differ.
 *
 * @param differ the line differ or <code>null</code> if none
 */
 private void setDiffer(IAnnotationModel differ) {
 if ( cast(ILineDiffer)differ  || differ is null) {
 if (fLineDiffer !is differ) {
 if (fLineDiffer !is null) {
 (cast(IAnnotationModel) fLineDiffer).removeAnnotationModelListener(fAnnotationListener);
 fLineDiffer= null;
 }
 fRevisionSelectionProvider.uninstall();
 }
 /**
 * Paints a single change region onto <code>gc</code>.
 *
 * @param range the range to paint
 * @param gc the {@link GC} to paint on
 */
 private void paintRange(RevisionRange range, GC gc) {
 ILineRange widgetRange= modelLinesToWidgetLines(range);
 * line numbers, since font styles (bold, italics...) can have larger
 * font metrics than the simple font used for the numbers.
 */
 int offset= fWidget.getOffsetAtLine(widgetLine);
 int widgetBaseline= fWidget.getBaseline(offset);
 FontMetrics fm = gc.getFontMetrics();
 int fontBaseline = fm.getAscent() + fm.getLeading();
 int baselineBias= widgetBaseline - fontBaseline;
 return Math.max(0, baselineBias);
 }
 /**
 * Looks up the color for a certain revision.
 *
 * @param revision the revision to get the color for
 * @param focus <code>true</code> if it is the focus revision
 * @return the color for the revision
 */
 private Color lookupColor(Revision revision, bool focus) {
 }
 /**
 * Returns the revision range that contains the given line, or
 * <code>null</code> if there is none.
 *
 * @param line the line of interest
 * @return the corresponding <code>RevisionRange</code> or <code>null</code>
 */
 private RevisionRange getRange(int line) {
 List ranges= getRangeCache();
 return null;
 }
 /**
 * Returns the sublist of all <code>RevisionRange</code>s that intersect with the given lines.
 *
 * @param lines the model based lines of interest
 * @return elementType: RevisionRange
 */
 private List getRanges(ILineRange lines) {
 List ranges= getRangeCache();
 }
 /**
 * Gets all change ranges of the revisions in the revision model and adapts them to the current
 * quick diff information. The list is cached.
 *
 * @return the list of all change regions, with diff information applied
 */
 private List getRangeCache() {
 if (fRevisionRanges is null) {
 if (fRevisionInfo is null) {
 * @since 3.3
 */
 private void clearRangeCache() {
 fRevisionRanges= null;
 }
 /**
 * Returns <code>true</code> if <code>range</code> contains <code>line</code>. A line is
 * not contained in a range if it is the range's exclusive end line.
 *
 * @param range the range to check whether it contains <code>line</code>
 * @param line the line the line
 * @return <code>true</code> if <code>range</code> contains <code>line</code>,
 *         <code>false</code> if not
 */
 return range.getStartLine() <= line && end(range) > line;
 }
 /**
 * Computes the end index of a line range.
 *
 * @param range a line range
 * @return the last line (exclusive) of <code>range</code>
 */
 private static int end(ILineRange range) {
 return range.getStartLine() + range.getNumberOfLines();
 }
 /**
 * Returns the visible extent of a document line range in widget lines.
 *
 * @param range the document line range
 * @return the visible extent of <code>range</code> in widget lines
 */
 private ILineRange modelLinesToWidgetLines(ILineRange range) {
 int widgetStartLine= -1;
 return new LineRange(widgetStartLine, widgetEndLine - widgetStartLine + 1);
 }
 /**
 * Returns the revision hover.
 *
 * @return the revision hover
 */
 public IAnnotationHover getHover() {
 return fHover;
 }
 /**
 * Computes and returns the bounds of the rectangle corresponding to a widget line range. The
 * rectangle is in pixel coordinates relative to the text widget's
 * {@link StyledText#getClientArea() client area} and has the width of the ruler.
 *
 * @param range the widget line range
 * @return the box bounds corresponding to <code>range</code>
 */
 private Rectangle computeBoxBounds(ILineRange range) {
 int y1= fWidget.getLinePixel(range.getStartLine());
 * Shows (or hides) the overview annotations.
 */
 private void updateOverviewAnnotations() {
 if (fAnnotationModel is null)
 return;
 Revision revision= fFocusRevision !is null ? fFocusRevision : fSelectedRevision;
 Map added= null;
 if (revision !is null) {
 added= new HashMap();
 }
 /**
 * Returns the character offset based region of a line range.
 *
 * @param lines the line range to convert
 * @return the character offset range corresponding to <code>range</code>
 * @throws BadLocationException if the line range is not within the document bounds
 */
 private IRegion toCharRegion(ILineRange lines)  {
 return new Region(offset, endOffset - offset);
 }
 /**
 * Handles the selection of a revision and informs listeners.
 *
 * @param revision the selected revision, <code>null</code> for none
 */
 void handleRevisionSelected(Revision revision) {
 fSelectedRevision= revision;
 fRevisionSelectionProvider.revisionSelected(revision);
 postRedraw();
 }
 /**
 * Handles the selection of a revision id and informs listeners
 *
 * @param id the selected revision id
 */
 void handleRevisionSelected(String id) {
 Assert.isLegal(id !is null);
 if (fRevisionInfo is null)
 handleRevisionSelected(cast(Revision) null);
 }
 /**
 * Returns the selection provider.
 *
 * @return the selection provider
 */
 public RevisionSelectionProvider getRevisionSelectionProvider() {
 return fRevisionSelectionProvider;
 }
 /**
 * Updates the focus line with a new line.
 *
 * @param line the new focus line, -1 for no focus
 */
 private void updateFocusLine(int line) {
 if (fFocusLine !is line)
 onFocusLineChanged(fFocusLine, line);
 }
 /**
 * Handles a changing focus line.
 *
 * @param previousLine the old focus line (-1 for no focus)
 * @param nextLine the new focus line (-1 for no focus)
 */
 private void onFocusLineChanged(int previousLine, int nextLine) {
-if cast(DEBUG)
+if (DEBUG)
-System.out_.println("line: " + previousLine + " > " + nextLine); //$NON-NLS-1$ //$NON-NLS-2$
+System.out_.println("line: " ~ previousLine ~ " > " ~ nextLine); //$NON-NLS-1$ //$NON-NLS-2$
 fFocusLine= nextLine;
 RevisionRange region= getRange(nextLine);
 updateFocusRange(region);
 }
 /**
 * Updates the focus range.
 *
 * @param range the new focus range, <code>null</code> for no focus
 */
 private void updateFocusRange(RevisionRange range) {
 if (range !is fFocusRange)
 onFocusRangeChanged(fFocusRange, range);
 }
 /**
 * Handles a changing focus range.
 *
 * @param previousRange the old focus range (<code>null</code> for no focus)
 * @param nextRange the new focus range (<code>null</code> for no focus)
 */
 private void onFocusRangeChanged(RevisionRange previousRange, RevisionRange nextRange) {
-if cast(DEBUG)
+if (DEBUG)
 System.out_.println("range: " + previousRange + " > " + nextRange); //$NON-NLS-1$ //$NON-NLS-2$
 fFocusRange= nextRange;
 Revision revision= nextRange is null ? null : nextRange.getRevision();
 updateFocusRevision(revision);
 }
 onFocusRevisionChanged(fFocusRevision, revision);
 }
 /**
 * Handles a changing focus revision.
 *
 * @param previousRevision the old focus revision (<code>null</code> for no focus)
 * @param nextRevision the new focus revision (<code>null</code> for no focus)
 */
 private void onFocusRevisionChanged(Revision previousRevision, Revision nextRevision) {
-if cast(DEBUG)
+if (DEBUG)
 System.out_.println("revision: " + previousRevision + " > " + nextRevision); //$NON-NLS-1$ //$NON-NLS-2$
 fFocusRevision= nextRevision;
 uninstallWheelHandler();
 installWheelHandler();
 updateOverviewAnnotations();
 }
 }
 /**
 * Handles a mouse wheel event.
 *
 * @param event the mouse wheel event
 */
 private void handleMouseWheel(Event event) {
 bool up= event.count > 0;
 int documentHoverLine= fFocusLine;
 }
 /**
 * Translates a y coordinate in the pixel coordinates of the column's control to a document line
 * number.
 *
 * @param y the y coordinate
 * @return the corresponding document line, -1 for no line
 * @see CompositeRuler#toDocumentLineNumber(int)
 */
 private int toDocumentLineNumber(int y) {
 fParentRuler.immediateUpdate();
 }
 /**
 * Returns the width of the column.
 *
 * @return the width of the column
 */
 private int getWidth() {
 return fColumn.getWidth();
 }
 /**
 * Returns the System background color for list widgets.
 *
 * @return the System background color for list widgets
 */
 private Color getBackground() {
 if (fBackground is null)
 return fWidget.getDisplay().getSystemColor(DWT.COLOR_LIST_BACKGROUND);
 return fBackground;
 }
 /**
 * Sets the hover later returned by {@link #getHover()}.
 *
 * @param hover the hover
 */
 public void setHover(IAnnotationHover hover) {
 // TODO ignore for now - must make revision hover settable from outside
 }
 /**
 * Returns <code>true</code> if the receiver can provide a hover for a certain document line.
 *
 * @param activeLine the document line of interest
 * @return <code>true</code> if the receiver can provide a hover
 */
 public bool hasHover(int activeLine) {
 return cast(ISourceViewer)fViewer && fHover.getHoverLineRange(cast(ISourceViewer) fViewer, activeLine) !is null;
 }
 /**
 * Returns the revision at a certain document offset, or <code>null</code> for none.
 *
 * @param offset the document offset
 * @return the revision at offset, or <code>null</code> for none
 */
 Revision getRevision(int offset) {
 IDocument document= fViewer.getDocument();
 return null;
 }
 /**
 * Returns <code>true</code> if a revision model has been set, <code>false</code> otherwise.
 *
 * @return <code>true</code> if a revision model has been set, <code>false</code> otherwise
 */
 public bool hasInformation() {
 return fRevisionInfo !is null;
 }
 /**
 * Returns the width in chars required to display information.
 *
 * @return the width in chars required to display information
 * @since 3.3
 */
 public int getRequiredWidth() {
 if (fRequiredWidth is -1) {
 return fRequiredWidth;
 }
 /**
 * Enables showing the revision id.
 *
 * @param show <code>true</code> to show the revision, <code>false</code> to hide it
 */
 public void showRevisionId(bool show) {
 if (fShowRevision !is show) {
 fRequiredWidth= -1;
 fRevisionIdChars= 0;
 fShowRevision= show;
 postRedraw();
 }
 }
 /**
 * Enables showing the revision author.
 *
 * @param show <code>true</code> to show the author, <code>false</code> to hide it
 */
 public void showRevisionAuthor(bool show) {
 if (fShowAuthor !is show) {
 fRequiredWidth= -1;
 }
 }
 /**
 * Adds a revision listener.
 *
 * @param listener the listener
 * @since 3.3
 */
 public void addRevisionListener(IRevisionListener listener) {
 fRevisionListeners.add(listener);
 }
 /**
 * Removes a revision listener.
 *
 * @param listener the listener
 * @since 3.3
 */
 public void removeRevisionListener(IRevisionListener listener) {
 fRevisionListeners.remove(listener);
 }
 /**
 * Informs the revision listeners about a change.
 *
 * @since 3.3
 */
 private void informListeners() {
 if (fRevisionInfo is null || fRevisionListeners.isEmpty())
 return;

Mercurial > projects > dwt-addons

comparison dwtx/jface/internal/text/revisions/RevisionPainter.d @ 150:5cf141e43417