| /* |
| * Copyright 2000-2006 Sun Microsystems, Inc. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Sun designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Sun in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| |
| package sun.java2d.windows; |
| |
| import java.awt.Composite; |
| import java.awt.Shape; |
| import java.awt.geom.Path2D; |
| import java.awt.geom.PathIterator; |
| import sun.java2d.SunGraphics2D; |
| import sun.java2d.SurfaceData; |
| import sun.java2d.pipe.Region; |
| import sun.java2d.pipe.PixelDrawPipe; |
| import sun.java2d.pipe.PixelFillPipe; |
| import sun.java2d.pipe.ShapeDrawPipe; |
| import sun.java2d.pipe.SpanIterator; |
| import sun.java2d.loops.GraphicsPrimitive; |
| |
| /** |
| * DDRenderer |
| * |
| * This class accelerates rendering to a surface of type |
| * WinOffScreenSurfaceData. The renderers in here are simply java wrappers |
| * around native methods that do the real work. |
| */ |
| public class DDRenderer extends GDIRenderer { |
| |
| // |
| // Native implementations |
| // |
| native void doDrawLineDD(SurfaceData sData, |
| int color, |
| int x1, int y1, int x2, int y2); |
| native void doFillRectDD(SurfaceData sData, |
| int color, |
| int left, int top, |
| int right, int bottom); |
| native void doDrawRectDD(SurfaceData sData, |
| int color, |
| int x, int y, int w, int h); |
| |
| // |
| // Internal Java methods for rendering |
| // |
| |
| /** |
| * Clip the given line to the clip bounds in sg2d. |
| * Assume that the line passed in is given in the order of |
| * x1 <= x2, y1 <= y2 |
| */ |
| private void clipAndDrawLine(SunGraphics2D sg2d, |
| int x1, int y1, int x2, int y2) |
| { |
| // If any of these are true, the line lies outside of the |
| // clip bounds |
| Region clip = sg2d.getCompClip(); |
| int cx1 = clip.getLoX(); |
| int cy1 = clip.getLoY(); |
| int cx2 = clip.getHiX(); |
| int cy2 = clip.getHiY(); |
| // For each edge, clip the appropriate coordinate against |
| // that edge. We are only dealing with horizontal or vertical lines |
| // for now, so there is no interpolation between points to |
| // the proper clip coordinate. |
| if (x1 < cx1) x1 = cx1; |
| if (y1 < cy1) y1 = cy1; |
| if (x2 >= cx2) x2 = cx2 - 1; |
| if (y2 >= cy2) y2 = cy2 - 1; |
| // If the start moved past the end (or vice versa), |
| // then we are outside the clip. |
| if (x1 <= x2 && y1 <= y2) { |
| doDrawLineDD(sg2d.surfaceData, sg2d.pixel, x1, y1, x2, y2); |
| } |
| } |
| |
| // REMIND: This is just a hack to get WIDE lines to honor the |
| // necessary hinted pixelization rules. This should be replaced |
| // by a native FillSpans method or a getHintedStrokeGeneralPath() |
| // method that could be filled by the doShape method more quickly. |
| public void doFillSpans(SunGraphics2D sg2d, SpanIterator si) { |
| int box[] = new int[4]; |
| SurfaceData sd = sg2d.surfaceData; |
| while (si.nextSpan(box)) { |
| doFillRectDD(sd, sg2d.pixel, box[0], box[1], box[2], box[3]); |
| } |
| } |
| |
| |
| // |
| // Java wrappers for the primitive renderers |
| // |
| |
| /** |
| * drawLine draws a line between the pixel at x1, y1 and the |
| * pixel at x2, y2 (including the last pixel). |
| */ |
| public void drawLine(SunGraphics2D sg2d, |
| int x1, int y1, int x2, int y2) |
| { |
| // Note that we only handle horizontal or vertical lines through |
| // this renderer. This is because the implementation uses a fill |
| // Blt through DirectDraw, which only works for rectangle shapes. |
| if (x1 == x2 || y1 == y2) { |
| |
| int transx1 = x1 + sg2d.transX; |
| int transy1 = y1 + sg2d.transY; |
| int transx2 = x2 + sg2d.transX; |
| int transy2 = y2 + sg2d.transY; |
| int t; |
| // First, set the ordering of the line coordinates; |
| // clipAndDrawLine() expects x1 < x2 and y1 < y2 |
| if (transx1 > transx2) { |
| t = transx1; |
| transx1 = transx2; |
| transx2 = t; |
| } |
| if (transy1 > transy2) { |
| t = transy1; |
| transy1 = transy2; |
| transy2 = t; |
| } |
| clipAndDrawLine(sg2d, transx1, transy1, transx2, transy2); |
| } |
| else { |
| // Punt to our superclass renderer to render diagonal lines |
| super.drawLine(sg2d, x1, y1, x2, y2); |
| } |
| } |
| |
| |
| /** |
| * fillRect filles a rect from the pixel at x, y to (but not including) |
| * the pixel at (x + width), (y + height) |
| */ |
| public void fillRect(SunGraphics2D sg2d, |
| int x, int y, int width, int height) |
| { |
| int clipLeft, clipTop, clipRight, clipBottom; |
| |
| // REMIND: This check should probably go in SunGraphics2D instead. |
| if (width <= 0 || height <= 0) { |
| return; |
| } |
| |
| // Here we clip the fill rect to the size of the clip bounds in sg2d. |
| // The native code can then assume that it receives a non-empty, post- |
| // clipped primitive. |
| clipLeft = x + sg2d.transX; |
| clipTop = y + sg2d.transY; |
| clipRight = clipLeft + width; |
| clipBottom = clipTop + height; |
| |
| Region clip = sg2d.getCompClip(); |
| |
| // Clip each edge of the rect to the appropriate edge of the clip |
| // bounds. |
| if (clipLeft < clip.getLoX()) clipLeft = clip.getLoX(); |
| if (clipTop < clip.getLoY()) clipTop = clip.getLoY(); |
| if (clipRight > clip.getHiX()) clipRight = clip.getHiX(); |
| if (clipBottom > clip.getHiY()) clipBottom = clip.getHiY(); |
| |
| if (clipRight > clipLeft && clipBottom > clipTop) { |
| doFillRectDD(sg2d.surfaceData, sg2d.pixel, clipLeft, clipTop, |
| clipRight, clipBottom); |
| } |
| } |
| |
| |
| /** |
| * draw a rectangle outline starting at x, y and going to the pixel |
| * at (x + width), (y + width) (including the lower right pixel) |
| */ |
| public void drawRect(SunGraphics2D sg2d, |
| int x, int y, int width, int height) |
| { |
| if (width < 2 || height < 2) { |
| fillRect(sg2d, x, y, width+1, height+1); |
| return; |
| } |
| int transx = x + sg2d.transX; |
| int transy = y + sg2d.transY; |
| Region clip = sg2d.getCompClip(); |
| if (!clip.encompassesXYWH(transx, transy, width+1, height+1)) { |
| // Rect needs clipping - draw each edge separately, clipping |
| // as we go. |
| // Prefer longer horizontal lines if possible. |
| clipAndDrawLine(sg2d, transx, transy, |
| transx + width, transy); |
| clipAndDrawLine(sg2d, transx, transy + 1, |
| transx, transy + height - 1); |
| clipAndDrawLine(sg2d, transx + width, transy + 1, |
| transx + width, transy + height - 1); |
| clipAndDrawLine(sg2d, transx, transy + height, |
| transx + width, transy + height); |
| } else { |
| // No clipping needed - just call native method which draws |
| // all edges in one method |
| doDrawRectDD(sg2d.surfaceData, sg2d.pixel, transx, transy, |
| width, height); |
| } |
| } |
| |
| @Override |
| public native void devCopyArea(SurfaceData sData, |
| int srcx, int srcy, int dx, int dy, |
| int w, int h); |
| |
| public DDRenderer traceWrapDD() { |
| return new Tracer(); |
| } |
| |
| public static class Tracer extends DDRenderer { |
| void doDrawLine(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x1, int y1, int x2, int y2) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIDrawLine"); |
| super.doDrawLine(sData, clip, comp, color, x1, y1, x2, y2); |
| } |
| void doDrawRect(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIDrawRect"); |
| super.doDrawRect(sData, clip, comp, color, x, y, w, h); |
| } |
| void doDrawRoundRect(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h, |
| int arcW, int arcH) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIDrawRoundRect"); |
| super.doDrawRoundRect(sData, clip, comp, color, |
| x, y, w, h, arcW, arcH); |
| } |
| void doDrawOval(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIDrawOval"); |
| super.doDrawOval(sData, clip, comp, color, x, y, w, h); |
| } |
| void doDrawArc(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h, |
| int angleStart, int angleExtent) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIDrawArc"); |
| super.doDrawArc(sData, clip, comp, color, x, y, w, h, |
| angleStart, angleExtent); |
| } |
| void doDrawPoly(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int transx, int transy, |
| int[] xpoints, int[] ypoints, |
| int npoints, boolean isclosed) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIDrawPoly"); |
| super.doDrawPoly(sData, clip, comp, color, transx, transy, |
| xpoints, ypoints, npoints, isclosed); |
| } |
| void doFillRect(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIFillRect"); |
| super.doFillRect(sData, clip, comp, color, x, y, w, h); |
| } |
| void doFillRoundRect(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h, |
| int arcW, int arcH) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIFillRoundRect"); |
| super.doFillRoundRect(sData, clip, comp, color, |
| x, y, w, h, arcW, arcH); |
| } |
| void doFillOval(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIFillOval"); |
| super.doFillOval(sData, clip, comp, color, x, y, w, h); |
| } |
| void doFillArc(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int x, int y, int w, int h, |
| int angleStart, int angleExtent) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIFillArc"); |
| super.doFillArc(sData, clip, comp, color, x, y, w, h, |
| angleStart, angleExtent); |
| } |
| void doFillPoly(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int transx, int transy, |
| int[] xpoints, int[] ypoints, |
| int npoints) |
| { |
| GraphicsPrimitive.tracePrimitive("GDIFillPoly"); |
| super.doFillPoly(sData, clip, comp, color, transx, transy, |
| xpoints, ypoints, npoints); |
| } |
| void doShape(SurfaceData sData, |
| Region clip, Composite comp, int color, |
| int transX, int transY, |
| Path2D.Float p2df, boolean isfill) |
| { |
| GraphicsPrimitive.tracePrimitive(isfill |
| ? "GDIFillShape" |
| : "GDIDrawShape"); |
| super.doShape(sData, clip, comp, color, |
| transX, transY, p2df, isfill); |
| } |
| public void devCopyArea(SurfaceData sData, |
| int srcx, int srcy, |
| int dx, int dy, |
| int w, int h) |
| { |
| GraphicsPrimitive.tracePrimitive("DXCopyArea"); |
| super.devCopyArea(sData, srcx, srcy, dx, dy, w, h); |
| } |
| void doDrawLineDD(SurfaceData sData, |
| int color, |
| int x1, int y1, int x2, int y2) |
| { |
| GraphicsPrimitive.tracePrimitive("DXDrawLine"); |
| super.doDrawLineDD(sData, color, x1, y1, x2, y2); |
| } |
| void doFillRectDD(SurfaceData sData, |
| int color, |
| int left, int top, |
| int right, int bottom) |
| { |
| GraphicsPrimitive.tracePrimitive("DXFillRect"); |
| super.doFillRectDD(sData, color, left, top, right, bottom); |
| } |
| void doDrawRectDD(SurfaceData sData, |
| int color, |
| int x, int y, int w, int h) |
| { |
| GraphicsPrimitive.tracePrimitive("DXDrawRect"); |
| super.doDrawRectDD(sData, color, x, y, w, h); |
| } |
| } |
| } |
