mirror of
https://github.com/openjdk/jdk.git
synced 2026-05-17 17:07:53 +00:00
430 lines
16 KiB
Java
430 lines
16 KiB
Java
/*
|
|
* Copyright (c) 2008, 2018, Oracle and/or its affiliates. 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. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package sun.java2d.pipe;
|
|
|
|
import java.awt.Shape;
|
|
import java.awt.BasicStroke;
|
|
import java.awt.geom.Line2D;
|
|
import java.awt.geom.Rectangle2D;
|
|
import java.awt.geom.AffineTransform;
|
|
import sun.java2d.SunGraphics2D;
|
|
import sun.awt.SunHints;
|
|
|
|
/**
|
|
* This class converts calls to the basic pixel rendering methods
|
|
* into calls to the methods on a ParallelogramPipe.
|
|
* Most calls are transformed into calls to the fill(Shape) method
|
|
* by the parent PixelToShapeConverter class, but some calls are
|
|
* transformed into calls to fill/drawParallelogram().
|
|
*/
|
|
public class PixelToParallelogramConverter extends PixelToShapeConverter
|
|
implements ShapeDrawPipe
|
|
{
|
|
ParallelogramPipe outrenderer;
|
|
double minPenSize;
|
|
double normPosition;
|
|
double normRoundingBias;
|
|
boolean adjustfill;
|
|
|
|
/**
|
|
* @param shapepipe pipeline to forward shape calls to
|
|
* @param pgrampipe pipeline to forward parallelogram calls to
|
|
* (and drawLine calls if possible)
|
|
* @param minPenSize minimum pen size for dropout control
|
|
* @param normPosition sub-pixel location to normalize endpoints
|
|
* for STROKE_NORMALIZE cases
|
|
* @param adjustfill boolean to control whethere normalization
|
|
* constants are also applied to fill operations
|
|
* (normally true for non-AA, false for AA)
|
|
*/
|
|
public PixelToParallelogramConverter(ShapeDrawPipe shapepipe,
|
|
ParallelogramPipe pgrampipe,
|
|
double minPenSize,
|
|
double normPosition,
|
|
boolean adjustfill)
|
|
{
|
|
super(shapepipe);
|
|
outrenderer = pgrampipe;
|
|
this.minPenSize = minPenSize;
|
|
this.normPosition = normPosition;
|
|
this.normRoundingBias = 0.5 - normPosition;
|
|
this.adjustfill = adjustfill;
|
|
}
|
|
|
|
public void drawLine(SunGraphics2D sg2d,
|
|
int x1, int y1, int x2, int y2)
|
|
{
|
|
if (!drawGeneralLine(sg2d, x1, y1, x2, y2)) {
|
|
super.drawLine(sg2d, x1, y1, x2, y2);
|
|
}
|
|
}
|
|
|
|
public void drawRect(SunGraphics2D sg2d,
|
|
int x, int y, int w, int h)
|
|
{
|
|
if (w >= 0 && h >= 0) {
|
|
if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
|
|
BasicStroke bs = ((BasicStroke) sg2d.stroke);
|
|
if (w > 0 && h > 0) {
|
|
if (bs.getLineJoin() == BasicStroke.JOIN_MITER &&
|
|
bs.getDashArray() == null)
|
|
{
|
|
double lw = bs.getLineWidth();
|
|
drawRectangle(sg2d, x, y, w, h, lw);
|
|
return;
|
|
}
|
|
} else {
|
|
// Note: This calls the integer version which
|
|
// will verify that the local drawLine optimizations
|
|
// work and call super.drawLine(), if not.
|
|
drawLine(sg2d, x, y, x+w, y+h);
|
|
return;
|
|
}
|
|
}
|
|
super.drawRect(sg2d, x, y, w, h);
|
|
}
|
|
}
|
|
|
|
public void fillRect(SunGraphics2D sg2d,
|
|
int x, int y, int w, int h)
|
|
{
|
|
if (w > 0 && h > 0) {
|
|
fillRectangle(sg2d, x, y, w, h);
|
|
}
|
|
}
|
|
|
|
public void draw(SunGraphics2D sg2d, Shape s) {
|
|
if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
|
|
BasicStroke bs = ((BasicStroke) sg2d.stroke);
|
|
if (s instanceof Rectangle2D) {
|
|
if (bs.getLineJoin() == BasicStroke.JOIN_MITER &&
|
|
bs.getDashArray() == null)
|
|
{
|
|
Rectangle2D r2d = (Rectangle2D) s;
|
|
double w = r2d.getWidth();
|
|
double h = r2d.getHeight();
|
|
double x = r2d.getX();
|
|
double y = r2d.getY();
|
|
if (w >= 0 && h >= 0) {
|
|
double lw = bs.getLineWidth();
|
|
drawRectangle(sg2d, x, y, w, h, lw);
|
|
}
|
|
return;
|
|
}
|
|
} else if (s instanceof Line2D) {
|
|
Line2D l2d = (Line2D) s;
|
|
if (drawGeneralLine(sg2d,
|
|
l2d.getX1(), l2d.getY1(),
|
|
l2d.getX2(), l2d.getY2()))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
outpipe.draw(sg2d, s);
|
|
}
|
|
|
|
public void fill(SunGraphics2D sg2d, Shape s) {
|
|
if (s instanceof Rectangle2D) {
|
|
Rectangle2D r2d = (Rectangle2D) s;
|
|
double w = r2d.getWidth();
|
|
double h = r2d.getHeight();
|
|
if (w > 0 && h > 0) {
|
|
double x = r2d.getX();
|
|
double y = r2d.getY();
|
|
fillRectangle(sg2d, x, y, w, h);
|
|
}
|
|
return;
|
|
}
|
|
|
|
outpipe.fill(sg2d, s);
|
|
}
|
|
|
|
static double len(double x, double y) {
|
|
return ((x == 0) ? Math.abs(y)
|
|
: ((y == 0) ? Math.abs(x)
|
|
: Math.sqrt(x * x + y * y)));
|
|
}
|
|
|
|
double normalize(double v) {
|
|
return Math.floor(v + normRoundingBias) + normPosition;
|
|
}
|
|
|
|
public boolean drawGeneralLine(SunGraphics2D sg2d,
|
|
double ux1, double uy1,
|
|
double ux2, double uy2)
|
|
{
|
|
if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM ||
|
|
sg2d.strokeState == SunGraphics2D.STROKE_THINDASHED)
|
|
{
|
|
return false;
|
|
}
|
|
BasicStroke bs = (BasicStroke) sg2d.stroke;
|
|
int cap = bs.getEndCap();
|
|
if (cap == BasicStroke.CAP_ROUND || bs.getDashArray() != null) {
|
|
// TODO: we could construct the GeneralPath directly
|
|
// for CAP_ROUND and save a lot of processing in that case...
|
|
// And again, we would need to deal with dropout control...
|
|
return false;
|
|
}
|
|
double lw = bs.getLineWidth();
|
|
// Save the original dx, dy in case we need it to transform
|
|
// the linewidth as a perpendicular vector below
|
|
double dx = ux2 - ux1;
|
|
double dy = uy2 - uy1;
|
|
double x1, y1, x2, y2;
|
|
switch (sg2d.transformState) {
|
|
case SunGraphics2D.TRANSFORM_GENERIC:
|
|
case SunGraphics2D.TRANSFORM_TRANSLATESCALE:
|
|
{
|
|
double[] coords = {ux1, uy1, ux2, uy2};
|
|
sg2d.transform.transform(coords, 0, coords, 0, 2);
|
|
x1 = coords[0];
|
|
y1 = coords[1];
|
|
x2 = coords[2];
|
|
y2 = coords[3];
|
|
}
|
|
break;
|
|
case SunGraphics2D.TRANSFORM_ANY_TRANSLATE:
|
|
case SunGraphics2D.TRANSFORM_INT_TRANSLATE:
|
|
{
|
|
double tx = sg2d.transform.getTranslateX();
|
|
double ty = sg2d.transform.getTranslateY();
|
|
x1 = ux1 + tx;
|
|
y1 = uy1 + ty;
|
|
x2 = ux2 + tx;
|
|
y2 = uy2 + ty;
|
|
}
|
|
break;
|
|
case SunGraphics2D.TRANSFORM_ISIDENT:
|
|
x1 = ux1;
|
|
y1 = uy1;
|
|
x2 = ux2;
|
|
y2 = uy2;
|
|
break;
|
|
default:
|
|
throw new InternalError("unknown TRANSFORM state...");
|
|
}
|
|
if (sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE) {
|
|
if (sg2d.strokeState == SunGraphics2D.STROKE_THIN &&
|
|
outrenderer instanceof PixelDrawPipe)
|
|
{
|
|
// PixelDrawPipes will add sg2d.transXY so we need to factor
|
|
// that out...
|
|
int ix1 = (int) Math.floor(x1 - sg2d.transX);
|
|
int iy1 = (int) Math.floor(y1 - sg2d.transY);
|
|
int ix2 = (int) Math.floor(x2 - sg2d.transX);
|
|
int iy2 = (int) Math.floor(y2 - sg2d.transY);
|
|
((PixelDrawPipe)outrenderer).drawLine(sg2d, ix1, iy1, ix2, iy2);
|
|
return true;
|
|
}
|
|
x1 = normalize(x1);
|
|
y1 = normalize(y1);
|
|
x2 = normalize(x2);
|
|
y2 = normalize(y2);
|
|
}
|
|
if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
|
|
// Transform the linewidth...
|
|
// calculate the scaling factor for a unit vector
|
|
// perpendicular to the original user space line.
|
|
double len = len(dx, dy);
|
|
if (len == 0) {
|
|
dx = len = 1;
|
|
// dy = 0; already
|
|
}
|
|
// delta transform the transposed (90 degree rotated) unit vector
|
|
double[] unitvector = {dy/len, -dx/len};
|
|
sg2d.transform.deltaTransform(unitvector, 0, unitvector, 0, 1);
|
|
lw *= len(unitvector[0], unitvector[1]);
|
|
}
|
|
lw = Math.max(lw, minPenSize);
|
|
dx = x2 - x1;
|
|
dy = y2 - y1;
|
|
double len = len(dx, dy);
|
|
double udx, udy;
|
|
if (len == 0) {
|
|
if (cap == BasicStroke.CAP_BUTT) {
|
|
return true;
|
|
}
|
|
udx = lw;
|
|
udy = 0;
|
|
} else {
|
|
udx = lw * dx / len;
|
|
udy = lw * dy / len;
|
|
}
|
|
double px = x1 + udy / 2.0;
|
|
double py = y1 - udx / 2.0;
|
|
if (cap == BasicStroke.CAP_SQUARE) {
|
|
px -= udx / 2.0;
|
|
py -= udy / 2.0;
|
|
dx += udx;
|
|
dy += udy;
|
|
}
|
|
outrenderer.fillParallelogram(sg2d, ux1, uy1, ux2, uy2,
|
|
px, py, -udy, udx, dx, dy);
|
|
return true;
|
|
}
|
|
|
|
public void fillRectangle(SunGraphics2D sg2d,
|
|
double rx, double ry,
|
|
double rw, double rh)
|
|
{
|
|
double px, py;
|
|
double dx1, dy1, dx2, dy2;
|
|
AffineTransform txform = sg2d.transform;
|
|
dx1 = txform.getScaleX();
|
|
dy1 = txform.getShearY();
|
|
dx2 = txform.getShearX();
|
|
dy2 = txform.getScaleY();
|
|
px = rx * dx1 + ry * dx2 + txform.getTranslateX();
|
|
py = rx * dy1 + ry * dy2 + txform.getTranslateY();
|
|
dx1 *= rw;
|
|
dy1 *= rw;
|
|
dx2 *= rh;
|
|
dy2 *= rh;
|
|
if (adjustfill &&
|
|
sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM &&
|
|
sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE)
|
|
{
|
|
double newx = normalize(px);
|
|
double newy = normalize(py);
|
|
dx1 = normalize(px + dx1) - newx;
|
|
dy1 = normalize(py + dy1) - newy;
|
|
dx2 = normalize(px + dx2) - newx;
|
|
dy2 = normalize(py + dy2) - newy;
|
|
px = newx;
|
|
py = newy;
|
|
}
|
|
outrenderer.fillParallelogram(sg2d, rx, ry, rx+rw, ry+rh,
|
|
px, py, dx1, dy1, dx2, dy2);
|
|
}
|
|
|
|
public void drawRectangle(SunGraphics2D sg2d,
|
|
double rx, double ry,
|
|
double rw, double rh,
|
|
double lw)
|
|
{
|
|
double px, py;
|
|
double dx1, dy1, dx2, dy2;
|
|
double lw1, lw2;
|
|
AffineTransform txform = sg2d.transform;
|
|
dx1 = txform.getScaleX();
|
|
dy1 = txform.getShearY();
|
|
dx2 = txform.getShearX();
|
|
dy2 = txform.getScaleY();
|
|
px = rx * dx1 + ry * dx2 + txform.getTranslateX();
|
|
py = rx * dy1 + ry * dy2 + txform.getTranslateY();
|
|
// lw along dx1,dy1 scale by transformed length of dx2,dy2 vectors
|
|
// and vice versa
|
|
lw1 = len(dx1, dy1) * lw;
|
|
lw2 = len(dx2, dy2) * lw;
|
|
dx1 *= rw;
|
|
dy1 *= rw;
|
|
dx2 *= rh;
|
|
dy2 *= rh;
|
|
if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM &&
|
|
sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE)
|
|
{
|
|
double newx = normalize(px);
|
|
double newy = normalize(py);
|
|
dx1 = normalize(px + dx1) - newx;
|
|
dy1 = normalize(py + dy1) - newy;
|
|
dx2 = normalize(px + dx2) - newx;
|
|
dy2 = normalize(py + dy2) - newy;
|
|
px = newx;
|
|
py = newy;
|
|
}
|
|
lw1 = Math.max(lw1, minPenSize);
|
|
lw2 = Math.max(lw2, minPenSize);
|
|
double len1 = len(dx1, dy1);
|
|
double len2 = len(dx2, dy2);
|
|
if (lw1 >= len1 || lw2 >= len2) {
|
|
// The line widths are large enough to consume the
|
|
// entire hole in the middle of the parallelogram
|
|
// so we can just fill the outer parallelogram.
|
|
fillOuterParallelogram(sg2d,
|
|
rx, ry, rx+rw, ry+rh,
|
|
px, py, dx1, dy1, dx2, dy2,
|
|
len1, len2, lw1, lw2);
|
|
} else {
|
|
outrenderer.drawParallelogram(sg2d,
|
|
rx, ry, rx+rw, ry+rh,
|
|
px, py, dx1, dy1, dx2, dy2,
|
|
lw1 / len1, lw2 / len2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This utility function handles the case where a drawRectangle
|
|
* operation discovered that the interior hole in the rectangle
|
|
* or parallelogram has been completely filled in by the stroke
|
|
* width. It calculates the outer parallelogram of the stroke
|
|
* and issues a single fillParallelogram request to fill it.
|
|
*/
|
|
public void fillOuterParallelogram(SunGraphics2D sg2d,
|
|
double ux1, double uy1,
|
|
double ux2, double uy2,
|
|
double px, double py,
|
|
double dx1, double dy1,
|
|
double dx2, double dy2,
|
|
double len1, double len2,
|
|
double lw1, double lw2)
|
|
{
|
|
double udx1 = dx1 / len1;
|
|
double udy1 = dy1 / len1;
|
|
double udx2 = dx2 / len2;
|
|
double udy2 = dy2 / len2;
|
|
if (len1 == 0) {
|
|
// len1 is 0, replace udxy1 with perpendicular of udxy2
|
|
if (len2 == 0) {
|
|
// both are 0, use a unit Y vector for udxy2
|
|
udx2 = 0;
|
|
udy2 = 1;
|
|
}
|
|
udx1 = udy2;
|
|
udy1 = -udx2;
|
|
} else if (len2 == 0) {
|
|
// len2 is 0, replace udxy2 with perpendicular of udxy1
|
|
udx2 = udy1;
|
|
udy2 = -udx1;
|
|
}
|
|
udx1 *= lw1;
|
|
udy1 *= lw1;
|
|
udx2 *= lw2;
|
|
udy2 *= lw2;
|
|
px -= (udx1 + udx2) / 2;
|
|
py -= (udy1 + udy2) / 2;
|
|
dx1 += udx1;
|
|
dy1 += udy1;
|
|
dx2 += udx2;
|
|
dy2 += udy2;
|
|
|
|
outrenderer.fillParallelogram(sg2d, ux1, uy1, ux2, uy2,
|
|
px, py, dx1, dy1, dx2, dy2);
|
|
}
|
|
}
|