JDK14/Java14源码在线阅读
/*
* Copyright (c) 1998, 2013, 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.
*/
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "jni.h"
#include "jni_util.h"
#include <jlong.h>
#include "j2d_md.h"
#include "PathConsumer2D.h"
#include "SpanIterator.h"
#include "sun_java2d_pipe_ShapeSpanIterator.h"
#include "java_awt_geom_PathIterator.h"
/*
* This structure holds all of the information needed to trace and
* manage a single line segment of the shape's outline.
*/
typedef struct {
jint curx;
jint cury;
jint lasty;
jint error;
jint bumpx;
jint bumperr;
jbyte windDir;
jbyte pad0;
jbyte pad1;
jbyte pad2;
} segmentData;
/*
* This structure holds all of the information needed to trace out
* the entire span list of a single Shape object.
*/
typedef struct {
PathConsumerVec funcs; /* Native PathConsumer function vector */
char state; /* Path delivery sequence state */
char evenodd; /* non-zero if path has EvenOdd winding rule */
char first; /* non-zero if first path segment */
char adjust; /* normalize to nearest (0.25, 0.25) */
jint lox; /* clip bbox low X */
jint loy; /* clip bbox low Y */
jint hix; /* clip bbox high X */
jint hiy; /* clip bbox high Y */
jfloat curx; /* current path point X coordinate */
jfloat cury; /* current path point Y coordinate */
jfloat movx; /* last moveto X coordinate */
jfloat movy; /* last moveto Y coordinate */
jfloat adjx; /* last X coordinate adjustment */
jfloat adjy; /* last Y coordinate adjustment */
jfloat pathlox; /* lowest X coordinate in path */
jfloat pathloy; /* lowest Y coordinate in path */
jfloat pathhix; /* highest X coordinate in path */
jfloat pathhiy; /* highest Y coordinate in path */
segmentData *segments; /* pointer to array of path segments */
int numSegments; /* number of segments entries in array */
int segmentsSize; /* size of array of path segments */
int lowSegment; /* lower limit of segments in active range */
int curSegment; /* index of next active segment to return */
int hiSegment; /* upper limit of segments in active range */
segmentData **segmentTable; /* pointers to segments being stepped */
} pathData;
#define STATE_INIT 0
#define STATE_HAVE_CLIP 1
#define STATE_HAVE_RULE 2
#define STATE_PATH_DONE 3
#define STATE_SPAN_STARTED 4
static jboolean subdivideLine(pathData *pd, int level,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1);
static jboolean subdivideQuad(pathData *pd, int level,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1,
jfloat x2, jfloat y2);
static jboolean subdivideCubic(pathData *pd, int level,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1,
jfloat x2, jfloat y2,
jfloat x3, jfloat y3);
static jboolean appendSegment(pathData *pd,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1);
static jboolean initSegmentTable(pathData *pd);
static void *ShapeSIOpen(JNIEnv *env, jobject iterator);
static void ShapeSIClose(JNIEnv *env, void *private);
static void ShapeSIGetPathBox(JNIEnv *env, void *private, jint pathbox[]);
static void ShapeSIIntersectClipBox(JNIEnv *env, void *private,
jint lox, jint loy, jint hix, jint hiy);
static jboolean ShapeSINextSpan(void *state, jint spanbox[]);
static void ShapeSISkipDownTo(void *private, jint y);
static jfieldID pSpanDataID;
static SpanIteratorFuncs ShapeSIFuncs = {
ShapeSIOpen,
ShapeSIClose,
ShapeSIGetPathBox,
ShapeSIIntersectClipBox,
ShapeSINextSpan,
ShapeSISkipDownTo
};
static LineToFunc PCLineTo;
static MoveToFunc PCMoveTo;
static QuadToFunc PCQuadTo;
static CubicToFunc PCCubicTo;
static ClosePathFunc PCClosePath;
static PathDoneFunc PCPathDone;
#define PDBOXPOINT(pd, x, y) \
do { \
if (pd->first) { \
pd->pathlox = pd->pathhix = x; \
pd->pathloy = pd->pathhiy = y; \
pd->first = 0; \
} else { \
if (pd->pathlox > x) pd->pathlox = x; \
if (pd->pathloy > y) pd->pathloy = y; \
if (pd->pathhix < x) pd->pathhix = x; \
if (pd->pathhiy < y) pd->pathhiy = y; \
} \
} while (0)
/*
* _ADJUST is the internal macro used to adjust a new endpoint
* and then invoke the "additional" code from the callers below
* which will adjust the control points as needed to match.
*
* When the "additional" code is executed, newadj[xy] will
* contain the adjustment applied to the new endpoint and
* pd->adj[xy] will still contain the previous adjustment
* that was applied to the old endpoint.
*/
#define _ADJUST(pd, x, y, additional) \
do { \
if (pd->adjust) { \
jfloat newx = (jfloat) floor(x + 0.25f) + 0.25f; \
jfloat newy = (jfloat) floor(y + 0.25f) + 0.25f; \
jfloat newadjx = newx - x; \
jfloat newadjy = newy - y; \
x = newx; \
y = newy; \
additional; \
pd->adjx = newadjx; \
pd->adjy = newadjy; \
} \
} while (0)
/*
* Adjust a single endpoint with no control points.
* "additional" code is a null statement.
*/
#define ADJUST1(pd, x1, y1) \
_ADJUST(pd, x1, y1, \
do { \
} while (0))
/*
* Adjust a quadratic curve. The _ADJUST macro takes care
* of the new endpoint and the "additional" code adjusts
* the single quadratic control point by the averge of
* the prior and the new adjustment amounts.
*/
#define ADJUST2(pd, x1, y1, x2, y2) \
_ADJUST(pd, x2, y2, \
do { \
x1 += (pd->adjx + newadjy) / 2; \
y1 += (pd->adjy + newadjy) / 2; \
} while (0))
/*
* Adjust a cubic curve. The _ADJUST macro takes care
* of the new endpoint and the "additional" code adjusts
* the first of the two cubic control points by the same
* amount that the prior endpoint was adjusted and then
* adjusts the second of the two control points by the
* same amount as the new endpoint was adjusted. This
* keeps the tangent lines from xy0 to xy1 and xy3 to xy2
* parallel before and after the adjustment.
*/
#define ADJUST3(pd, x1, y1, x2, y2, x3, y3) \
_ADJUST(pd, x3, y3, \
do { \
x1 += pd->adjx; \
y1 += pd->adjy; \
x2 += newadjx; \
y2 += newadjy; \
} while (0))
#define HANDLEMOVETO(pd, x0, y0, OOMERR) \
do { \
HANDLECLOSE(pd, OOMERR); \
ADJUST1(pd, x0, y0); \
pd->movx = x0; \
pd->movy = y0; \
PDBOXPOINT(pd, x0, y0); \
pd->curx = x0; \
pd->cury = y0; \
} while (0)
#define HANDLELINETO(pd, x1, y1, OOMERR) \
do { \
ADJUST1(pd, x1, y1); \
if (!subdivideLine(pd, 0, \
pd->curx, pd->cury, \
x1, y1)) { \
OOMERR; \
break; \
} \
PDBOXPOINT(pd, x1, y1); \
pd->curx = x1; \
pd->cury = y1; \
} while (0)
#define HANDLEQUADTO(pd, x1, y1, x2, y2, OOMERR) \
do { \
ADJUST2(pd, x1, y1, x2, y2); \
if (!subdivideQuad(pd, 0, \
pd->curx, pd->cury, \
x1, y1, x2, y2)) { \
OOMERR; \
break; \
} \
PDBOXPOINT(pd, x1, y1); \
PDBOXPOINT(pd, x2, y2); \
pd->curx = x2; \
pd->cury = y2; \
} while (0)
#define HANDLECUBICTO(pd, x1, y1, x2, y2, x3, y3, OOMERR) \
do { \
ADJUST3(pd, x1, y1, x2, y2, x3, y3); \
if (!subdivideCubic(pd, 0, \
pd->curx, pd->cury, \
x1, y1, x2, y2, x3, y3)) { \
OOMERR; \
break; \
} \
PDBOXPOINT(pd, x1, y1); \
PDBOXPOINT(pd, x2, y2); \
PDBOXPOINT(pd, x3, y3); \
pd->curx = x3; \
pd->cury = y3; \
} while (0)
#define HANDLECLOSE(pd, OOMERR) \
do { \
if (pd->curx != pd->movx || pd->cury != pd->movy) { \
if (!subdivideLine(pd, 0, \
pd->curx, pd->cury, \
pd->movx, pd->movy)) { \
OOMERR; \
break; \
} \
pd->curx = pd->movx; \
pd->cury = pd->movy; \
} \
} while (0)
#define HANDLEENDPATH(pd, OOMERR) \
do { \
HANDLECLOSE(pd, OOMERR); \
pd->state = STATE_PATH_DONE; \
} while (0)
static pathData *
GetSpanData(JNIEnv *env, jobject sr, int minState, int maxState)
{
pathData *pd = (pathData *) JNU_GetLongFieldAsPtr(env, sr, pSpanDataID);
if (pd == NULL) {
JNU_ThrowNullPointerException(env, "private data");
} else if (pd->state < minState || pd->state > maxState) {
JNU_ThrowInternalError(env, "bad path delivery sequence");
pd = NULL;
}
return pd;
}
static pathData *
MakeSpanData(JNIEnv *env, jobject sr)
{
pathData *pd = (pathData *) JNU_GetLongFieldAsPtr(env, sr, pSpanDataID);
if (pd != NULL) {
JNU_ThrowInternalError(env, "private data already initialized");
return NULL;
}
pd = calloc(1, sizeof(pathData));
if (pd == NULL) {
JNU_ThrowOutOfMemoryError(env, "private data");
} else {
/* Initialize PathConsumer2D struct header */
pd->funcs.moveTo = PCMoveTo;
pd->funcs.lineTo = PCLineTo;
pd->funcs.quadTo = PCQuadTo;
pd->funcs.cubicTo = PCCubicTo;
pd->funcs.closePath = PCClosePath;
pd->funcs.pathDone = PCPathDone;
/* Initialize ShapeSpanIterator fields */
pd->first = 1;
(*env)->SetLongField(env, sr, pSpanDataID, ptr_to_jlong(pd));
}
return pd;
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_initIDs
(JNIEnv *env, jclass src)
{
pSpanDataID = (*env)->GetFieldID(env, src, "pData", "J");
}
/*
* Class: sun_java2d_pipe_ShapeSpanIterator
* Method: setNormalize
* Signature: (Z)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_setNormalize
(JNIEnv *env, jobject sr, jboolean adjust)
{
pathData *pd;
pd = MakeSpanData(env, sr);
if (pd == NULL) {
return;
}
pd->adjust = adjust;
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_setOutputAreaXYXY
(JNIEnv *env, jobject sr, jint lox, jint loy, jint hix, jint hiy)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_INIT, STATE_INIT);
if (pd == NULL) {
return;
}
pd->lox = lox;
pd->loy = loy;
pd->hix = hix;
pd->hiy = hiy;
pd->state = STATE_HAVE_CLIP;
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_setRule
(JNIEnv *env, jobject sr, jint rule)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_CLIP, STATE_HAVE_CLIP);
if (pd == NULL) {
return;
}
pd->evenodd = (rule == java_awt_geom_PathIterator_WIND_EVEN_ODD);
pd->state = STATE_HAVE_RULE;
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_addSegment
(JNIEnv *env, jobject sr, jint type, jfloatArray coordObj)
{
jfloat coords[6];
jfloat x1, y1, x2, y2, x3, y3;
jboolean oom = JNI_FALSE;
pathData *pd;
int numpts = 0;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
(*env)->GetFloatArrayRegion(env, coordObj, 0, 6, coords);
if ((*env)->ExceptionCheck(env)) {
return;
}
switch (type) {
case java_awt_geom_PathIterator_SEG_MOVETO:
x1 = coords[0]; y1 = coords[1];
HANDLEMOVETO(pd, x1, y1, {oom = JNI_TRUE;});
break;
case java_awt_geom_PathIterator_SEG_LINETO:
x1 = coords[0]; y1 = coords[1];
HANDLELINETO(pd, x1, y1, {oom = JNI_TRUE;});
break;
case java_awt_geom_PathIterator_SEG_QUADTO:
x1 = coords[0]; y1 = coords[1];
x2 = coords[2]; y2 = coords[3];
HANDLEQUADTO(pd, x1, y1, x2, y2, {oom = JNI_TRUE;});
break;
case java_awt_geom_PathIterator_SEG_CUBICTO:
x1 = coords[0]; y1 = coords[1];
x2 = coords[2]; y2 = coords[3];
x3 = coords[4]; y3 = coords[5];
HANDLECUBICTO(pd, x1, y1, x2, y2, x3, y3, {oom = JNI_TRUE;});
break;
case java_awt_geom_PathIterator_SEG_CLOSE:
HANDLECLOSE(pd, {oom = JNI_TRUE;});
break;
default:
JNU_ThrowInternalError(env, "bad path segment type");
return;
}
if (oom) {
JNU_ThrowOutOfMemoryError(env, "path segment data");
return;
}
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_getPathBox
(JNIEnv *env, jobject sr, jintArray spanbox)
{
pathData *pd;
jint coords[4];
pd = GetSpanData(env, sr, STATE_PATH_DONE, STATE_PATH_DONE);
if (pd == NULL) {
return;
}
ShapeSIGetPathBox(env, pd, coords);
(*env)->SetIntArrayRegion(env, spanbox, 0, 4, coords);
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_intersectClipBox
(JNIEnv *env, jobject ri, jint clox, jint cloy, jint chix, jint chiy)
{
pathData *pd;
pd = GetSpanData(env, ri, STATE_PATH_DONE, STATE_PATH_DONE);
if (pd == NULL) {
return;
}
ShapeSIIntersectClipBox(env, pd, clox, cloy, chix, chiy);
}
JNIEXPORT jboolean JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_nextSpan
(JNIEnv *env, jobject sr, jintArray spanbox)
{
pathData *pd;
jboolean ret;
jint coords[4];
pd = GetSpanData(env, sr, STATE_PATH_DONE, STATE_SPAN_STARTED);
if (pd == NULL) {
return JNI_FALSE;
}
ret = ShapeSINextSpan(pd, coords);
if (ret) {
(*env)->SetIntArrayRegion(env, spanbox, 0, 4, coords);
}
return ret;
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_skipDownTo
(JNIEnv *env, jobject sr, jint y)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_PATH_DONE, STATE_SPAN_STARTED);
if (pd == NULL) {
return;
}
ShapeSISkipDownTo(pd, y);
}
JNIEXPORT jlong JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_getNativeIterator
(JNIEnv *env, jobject sr)
{
return ptr_to_jlong(&ShapeSIFuncs);
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_dispose
(JNIEnv *env, jobject sr)
{
pathData *pd = (pathData *) JNU_GetLongFieldAsPtr(env, sr, pSpanDataID);
if (pd == NULL) {
return;
}
if (pd->segments != NULL) {
free(pd->segments);
}
if (pd->segmentTable != NULL) {
free(pd->segmentTable);
}
free(pd);
(*env)->SetLongField(env, sr, pSpanDataID, jlong_zero);
}
#define OUT_XLO 1
#define OUT_XHI 2
#define OUT_YLO 4
#define OUT_YHI 8
#define CALCULATE_OUTCODES(pd, outc, x, y) \
do { \
if (y <= pd->loy) outc = OUT_YLO; \
else if (y >= pd->hiy) outc = OUT_YHI; \
else outc = 0; \
if (x <= pd->lox) outc |= OUT_XLO; \
else if (x >= pd->hix) outc |= OUT_XHI; \
} while (0)
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_appendPoly
(JNIEnv *env, jobject sr,
jintArray xArray, jintArray yArray, jint nPoints,
jint ixoff, jint iyoff)
{
pathData *pd;
int i;
jint *xPoints, *yPoints;
jboolean oom = JNI_FALSE;
jfloat xoff = (jfloat) ixoff, yoff = (jfloat) iyoff;
pd = GetSpanData(env, sr, STATE_HAVE_CLIP, STATE_HAVE_CLIP);
if (pd == NULL) {
return;
}
pd->evenodd = JNI_TRUE;
pd->state = STATE_HAVE_RULE;
if (pd->adjust) {
xoff += 0.25f;
yoff += 0.25f;
}
if (xArray == NULL || yArray == NULL) {
JNU_ThrowNullPointerException(env, "polygon data arrays");
return;
}
if ((*env)->GetArrayLength(env, xArray) < nPoints ||
(*env)->GetArrayLength(env, yArray) < nPoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "polygon data arrays");
return;
}
if (nPoints > 0) {
xPoints = (*env)->GetPrimitiveArrayCritical(env, xArray, NULL);
if (xPoints != NULL) {
yPoints = (*env)->GetPrimitiveArrayCritical(env, yArray, NULL);
if (yPoints != NULL) {
jint outc0;
jfloat x, y;
x = xPoints[0] + xoff;
y = yPoints[0] + yoff;
CALCULATE_OUTCODES(pd, outc0, x, y);
pd->movx = pd->curx = x;
pd->movy = pd->cury = y;
pd->pathlox = pd->pathhix = x;
pd->pathloy = pd->pathhiy = y;
pd->first = 0;
for (i = 1; !oom && i < nPoints; i++) {
jint outc1;
x = xPoints[i] + xoff;
y = yPoints[i] + yoff;
if (y == pd->cury) {
/* Horizontal segment - do not append */
if (x != pd->curx) {
/* Not empty segment - track change in X */
CALCULATE_OUTCODES(pd, outc0, x, y);
pd->curx = x;
if (pd->pathlox > x) pd->pathlox = x;
if (pd->pathhix < x) pd->pathhix = x;
}
continue;
}
CALCULATE_OUTCODES(pd, outc1, x, y);
outc0 &= outc1;
if (outc0 == 0) {
oom = !appendSegment(pd, pd->curx, pd->cury, x, y);
} else if (outc0 == OUT_XLO) {
oom = !appendSegment(pd, (jfloat) pd->lox, pd->cury,
(jfloat) pd->lox, y);
}
if (pd->pathlox > x) pd->pathlox = x;
if (pd->pathloy > y) pd->pathloy = y;
if (pd->pathhix < x) pd->pathhix = x;
if (pd->pathhiy < y) pd->pathhiy = y;
outc0 = outc1;
pd->curx = x;
pd->cury = y;
}
(*env)->ReleasePrimitiveArrayCritical(env, yArray,
yPoints, JNI_ABORT);
}
(*env)->ReleasePrimitiveArrayCritical(env, xArray,
xPoints, JNI_ABORT);
}
if (xPoints == NULL || yPoints == NULL) {
return;
}
}
if (!oom) {
HANDLEENDPATH(pd, {oom = JNI_TRUE;});
}
if (oom) {
JNU_ThrowOutOfMemoryError(env, "path segment data");
}
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_moveTo
(JNIEnv *env, jobject sr, jfloat x0, jfloat y0)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
HANDLEMOVETO(pd, x0, y0,
{JNU_ThrowOutOfMemoryError(env, "path segment data");});
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_lineTo
(JNIEnv *env, jobject sr, jfloat x1, jfloat y1)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
HANDLELINETO(pd, x1, y1,
{JNU_ThrowOutOfMemoryError(env, "path segment data");});
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_quadTo
(JNIEnv *env, jobject sr,
jfloat xm, jfloat ym, jfloat x1, jfloat y1)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
HANDLEQUADTO(pd, xm, ym, x1, y1,
{JNU_ThrowOutOfMemoryError(env, "path segment data");});
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_curveTo
(JNIEnv *env, jobject sr,
jfloat xm, jfloat ym,
jfloat xn, jfloat yn,
jfloat x1, jfloat y1)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
HANDLECUBICTO(pd, xm, ym, xn, yn, x1, y1,
{JNU_ThrowOutOfMemoryError(env, "path segment data");});
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_closePath
(JNIEnv *env, jobject sr)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
HANDLECLOSE(pd, {JNU_ThrowOutOfMemoryError(env, "path segment data");});
}
JNIEXPORT void JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_pathDone
(JNIEnv *env, jobject sr)
{
pathData *pd;
pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return;
}
HANDLEENDPATH(pd, {JNU_ThrowOutOfMemoryError(env, "path segment data");});
}
JNIEXPORT jlong JNICALL
Java_sun_java2d_pipe_ShapeSpanIterator_getNativeConsumer
(JNIEnv *env, jobject sr)
{
pathData *pd = GetSpanData(env, sr, STATE_HAVE_RULE, STATE_HAVE_RULE);
if (pd == NULL) {
return jlong_zero;
}
return ptr_to_jlong(&(pd->funcs));
}
static jboolean
PCMoveTo(PathConsumerVec *consumer,
jfloat x0, jfloat y0)
{
pathData *pd = (pathData *) consumer;
jboolean oom = JNI_FALSE;
HANDLEMOVETO(pd, x0, y0, {oom = JNI_TRUE;});
return oom;
}
static jboolean
PCLineTo(PathConsumerVec *consumer,
jfloat x1, jfloat y1)
{
pathData *pd = (pathData *) consumer;
jboolean oom = JNI_FALSE;
HANDLELINETO(pd, x1, y1, {oom = JNI_TRUE;});
return oom;
}
static jboolean
PCQuadTo(PathConsumerVec *consumer,
jfloat x1, jfloat y1,
jfloat x2, jfloat y2)
{
pathData *pd = (pathData *) consumer;
jboolean oom = JNI_FALSE;
HANDLEQUADTO(pd, x1, y1, x2, y2, {oom = JNI_TRUE;});
return oom;
}
static jboolean
PCCubicTo(PathConsumerVec *consumer,
jfloat x1, jfloat y1,
jfloat x2, jfloat y2,
jfloat x3, jfloat y3)
{
pathData *pd = (pathData *) consumer;
jboolean oom = JNI_FALSE;
HANDLECUBICTO(pd, x1, y1, x2, y2, x3, y3, {oom = JNI_TRUE;});
return oom;
}
static jboolean
PCClosePath(PathConsumerVec *consumer)
{
pathData *pd = (pathData *) consumer;
jboolean oom = JNI_FALSE;
HANDLECLOSE(pd, {oom = JNI_TRUE;});
return oom;
}
static jboolean
PCPathDone(PathConsumerVec *consumer)
{
pathData *pd = (pathData *) consumer;
jboolean oom = JNI_FALSE;
HANDLEENDPATH(pd, {oom = JNI_TRUE;});
return oom;
}
/*
* REMIND: CDECL needed for WIN32 "qsort"
*/
#ifdef _WIN32
#define CDECL __cdecl
#else
#define CDECL
#endif
#define SUBDIVIDE_MAX 10
#define MAX_FLAT_SQ (1.0 * 1.0)
#define GROW_SIZE 20
#define ERRSTEP_MAX (0x7fffffff)
#define FRACTTOJINT(f) ((jint) ((f) * (double) ERRSTEP_MAX))
#define minmax2(v1, v2, min, max) \
do { \
if (v1 < v2) { \
min = v1; \
max = v2; \
} else { \
min = v2; \
max = v1; \
} \
} while(0)
#define minmax3(v1, v2, v3, min, max) \
do { \
if (v1 < v2) { \
if (v1 < v3) { \
min = v1; \
max = (v2 < v3) ? v3 : v2; \
} else { \
max = v2; \
min = v3; \
} \
} else { \
if (v1 < v3) { \
max = v3; \
min = v2; \
} else { \
max = v1; \
min = (v2 < v3) ? v2 : v3; \
} \
} \
} while (0)
#define minmax4(v1, v2, v3, v4, min, max) \
do { \
if (v1 < v2) { \
if (v3 < v4) { \
max = (v2 < v4) ? v4 : v2; \
min = (v1 < v3) ? v1 : v3; \
} else { \
max = (v2 < v3) ? v3 : v2; \
min = (v1 < v4) ? v1 : v4; \
} \
} else { \
if (v3 < v4) { \
max = (v1 < v4) ? v4 : v1; \
min = (v2 < v3) ? v2 : v3; \
} else { \
max = (v1 < v3) ? v3 : v1; \
min = (v2 < v4) ? v2 : v4; \
} \
} \
} while(0)
static jfloat
ptSegDistSq(jfloat x0, jfloat y0,
jfloat x1, jfloat y1,
jfloat px, jfloat py)
{
jfloat dotprod, projlenSq;
/* Adjust vectors relative to x0,y0 */
/* x1,y1 becomes relative vector from x0,y0 to end of segment */
x1 -= x0;
y1 -= y0;
/* px,py becomes relative vector from x0,y0 to test point */
px -= x0;
py -= y0;
dotprod = px * x1 + py * y1;
if (dotprod <= 0.0) {
/* px,py is on the side of x0,y0 away from x1,y1 */
/* distance to segment is length of px,py vector */
/* "length of its (clipped) projection" is now 0.0 */
projlenSq = 0.0;
} else {
/* switch to backwards vectors relative to x1,y1 */
/* x1,y1 are already the negative of x0,y0=>x1,y1 */
/* to get px,py to be the negative of px,py=>x1,y1 */
/* the dot product of two negated vectors is the same */
/* as the dot product of the two normal vectors */
px = x1 - px;
py = y1 - py;
dotprod = px * x1 + py * y1;
if (dotprod <= 0.0) {
/* px,py is on the side of x1,y1 away from x0,y0 */
/* distance to segment is length of (backwards) px,py vector */
/* "length of its (clipped) projection" is now 0.0 */
projlenSq = 0.0;
} else {
/* px,py is between x0,y0 and x1,y1 */
/* dotprod is the length of the px,py vector */
/* projected on the x1,y1=>x0,y0 vector times the */
/* length of the x1,y1=>x0,y0 vector */
projlenSq = dotprod * dotprod / (x1 * x1 + y1 * y1);
}
}
/* Distance to line is now the length of the relative point */
/* vector minus the length of its projection onto the line */
/* (which is zero if the projection falls outside the range */
/* of the line segment). */
return px * px + py * py - projlenSq;
}
static jboolean
appendSegment(pathData *pd,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1)
{
jbyte windDir;
jint istartx, istarty, ilasty;
jfloat dx, dy, slope;
jfloat ystartbump;
jint bumpx, bumperr, error;
segmentData *seg;
if (y0 > y1) {
jfloat t;
t = x0; x0 = x1; x1 = t;
t = y0; y0 = y1; y1 = t;
windDir = -1;
} else {
windDir = 1;
}
/* We want to iterate at every horizontal pixel center (HPC) crossing. */
/* First calculate next highest HPC we will cross at the start. */
istarty = (jint) ceil(y0 - 0.5f);
/* Then calculate next highest HPC we would cross at the end. */
ilasty = (jint) ceil(y1 - 0.5f);
/* Ignore if we start and end outside clip, or on the same scanline. */
if (istarty >= ilasty || istarty >= pd->hiy || ilasty <= pd->loy) {
return JNI_TRUE;
}
/* We will need to insert this segment, check for room. */
if (pd->numSegments >= pd->segmentsSize) {
segmentData *newSegs;
int newSize = pd->segmentsSize + GROW_SIZE;
newSegs = (segmentData *) calloc(newSize, sizeof(segmentData));
if (newSegs == NULL) {
return JNI_FALSE;
}
if (pd->segments != NULL) {
memcpy(newSegs, pd->segments,
sizeof(segmentData) * pd->segmentsSize);
free(pd->segments);
}
pd->segments = newSegs;
pd->segmentsSize = newSize;
}
dx = x1 - x0;
dy = y1 - y0;
slope = dx / dy;
/*
* The Y coordinate of the first HPC was calculated as istarty. We
* now need to calculate the corresponding X coordinate (both integer
* version for span start coordinate and float version for sub-pixel
* error calculation).
*/
/* First, how far does y bump to get to next HPC? */
ystartbump = istarty + 0.5f - y0;
/* Now, bump the float x coordinate to get X sample at that HPC. */
x0 += ystartbump * dx / dy;
/* Now calculate the integer coordinate that such a span starts at. */
/* NOTE: Span inclusion is based on vertical pixel centers (VPC). */
istartx = (jint) ceil(x0 - 0.5f);
/* What is the lower bound of the per-scanline change in the X coord? */
bumpx = (jint) floor(slope);
/* What is the subpixel amount by which the bumpx is off? */
bumperr = FRACTTOJINT(slope - floor(slope));
/* Finally, find out how far the x coordinate can go before next VPC. */
error = FRACTTOJINT(x0 - (istartx - 0.5f));
seg = &pd->segments[pd->numSegments++];
seg->curx = istartx;
seg->cury = istarty;
seg->lasty = ilasty;
seg->error = error;
seg->bumpx = bumpx;
seg->bumperr = bumperr;
seg->windDir = windDir;
return JNI_TRUE;
}
/*
* Lines don't really need to be subdivided, but this function performs
* the same trivial rejections and reductions that the curve subdivision
* functions perform before it hands the coordinates off to the appendSegment
* function.
*/
static jboolean
subdivideLine(pathData *pd, int level,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1)
{
jfloat miny, maxy;
jfloat minx, maxx;
minmax2(x0, x1, minx, maxx);
minmax2(y0, y1, miny, maxy);
if (maxy <= pd->loy || miny >= pd->hiy || minx >= pd->hix) {
return JNI_TRUE;
}
if (maxx <= pd->lox) {
return appendSegment(pd, maxx, y0, maxx, y1);
}
return appendSegment(pd, x0, y0, x1, y1);
}
static jboolean
subdivideQuad(pathData *pd, int level,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1,
jfloat x2, jfloat y2)
{
jfloat miny, maxy;
jfloat minx, maxx;
minmax3(x0, x1, x2, minx, maxx);
minmax3(y0, y1, y2, miny, maxy);
if (maxy <= pd->loy || miny >= pd->hiy || minx >= pd->hix) {
return JNI_TRUE;
}
if (maxx <= pd->lox) {
return appendSegment(pd, maxx, y0, maxx, y2);
}
if (level < SUBDIVIDE_MAX) {
/* Test if the curve is flat enough for insertion. */
if (ptSegDistSq(x0, y0, x2, y2, x1, y1) > MAX_FLAT_SQ) {
jfloat cx1, cx2;
jfloat cy1, cy2;
cx1 = (x0 + x1) / 2.0f;
cx2 = (x1 + x2) / 2.0f;
x1 = (cx1 + cx2) / 2.0f;
cy1 = (y0 + y1) / 2.0f;
cy2 = (y1 + y2) / 2.0f;
y1 = (cy1 + cy2) / 2.0f;
level++;
return (subdivideQuad(pd, level, x0, y0, cx1, cy1, x1, y1) &&
subdivideQuad(pd, level, x1, y1, cx2, cy2, x2, y2));
}
}
return appendSegment(pd, x0, y0, x2, y2);
}
static jboolean
subdivideCubic(pathData *pd, int level,
jfloat x0, jfloat y0,
jfloat x1, jfloat y1,
jfloat x2, jfloat y2,
jfloat x3, jfloat y3)
{
jfloat miny, maxy;
jfloat minx, maxx;
minmax4(x0, x1, x2, x3, minx, maxx);
minmax4(y0, y1, y2, y3, miny, maxy);
if (maxy <= pd->loy || miny >= pd->hiy || minx >= pd->hix) {
return JNI_TRUE;
}
if (maxx <= pd->lox) {
return appendSegment(pd, maxx, y0, maxx, y3);
}
if (level < SUBDIVIDE_MAX) {
/* Test if the curve is flat enough for insertion. */
if (ptSegDistSq(x0, y0, x3, y3, x1, y1) > MAX_FLAT_SQ ||
ptSegDistSq(x0, y0, x3, y3, x2, y2) > MAX_FLAT_SQ)
{
jfloat ctrx, cx12, cx21;
jfloat ctry, cy12, cy21;
ctrx = (x1 + x2) / 2.0f;
x1 = (x0 + x1) / 2.0f;
x2 = (x2 + x3) / 2.0f;
cx12 = (x1 + ctrx) / 2.0f;
cx21 = (ctrx + x2) / 2.0f;
ctrx = (cx12 + cx21) / 2.0f;
ctry = (y1 + y2) / 2.0f;
y1 = (y0 + y1) / 2.0f;
y2 = (y2 + y3) / 2.0f;
cy12 = (y1 + ctry) / 2.0f;
cy21 = (ctry + y2) / 2.0f;
ctry = (cy12 + cy21) / 2.0f;
level++;
return (subdivideCubic(pd, level, x0, y0, x1, y1,
cx12, cy12, ctrx, ctry) &&
subdivideCubic(pd, level, ctrx, ctry, cx21, cy21,
x2, y2, x3, y3));
}
}
return appendSegment(pd, x0, y0, x3, y3);
}
static int CDECL
sortSegmentsByLeadingY(const void *elem1, const void *elem2)
{
segmentData *seg1 = *(segmentData **)elem1;
segmentData *seg2 = *(segmentData **)elem2;
if (seg1->cury < seg2->cury) {
return -1;
}
if (seg1->cury > seg2->cury) {
return 1;
}
if (seg1->curx < seg2->curx) {
return -1;
}
if (seg1->curx > seg2->curx) {
return 1;
}
if (seg1->lasty < seg2->lasty) {
return -1;
}
if (seg1->lasty > seg2->lasty) {
return 1;
}
return 0;
}
static void *
ShapeSIOpen(JNIEnv *env, jobject iterator)
{
return GetSpanData(env, iterator, STATE_PATH_DONE, STATE_PATH_DONE);
}
static void
ShapeSIClose(JNIEnv *env, void *private)
{
}
static void
ShapeSIGetPathBox(JNIEnv *env, void *private, jint pathbox[])
{
pathData *pd = (pathData *)private;
pathbox[0] = (jint) floor(pd->pathlox);
pathbox[1] = (jint) floor(pd->pathloy);
pathbox[2] = (jint) ceil(pd->pathhix);
pathbox[3] = (jint) ceil(pd->pathhiy);
}
/* Adjust the clip box from the given bounds. Used to constrain
the output to a device clip
*/
static void
ShapeSIIntersectClipBox(JNIEnv *env, void *private,
jint clox, jint cloy, jint chix, jint chiy)
{
pathData *pd = (pathData *)private;
if (clox > pd->lox) {
pd->lox = clox;
}
if (cloy > pd->loy) {
pd->loy = cloy;
}
if (chix < pd->hix) {
pd->hix = chix;
}
if (chiy < pd->hiy) {
pd->hiy = chiy;
}
}
static jboolean
ShapeSINextSpan(void *state, jint spanbox[])
{
pathData *pd = (pathData *)state;
int lo, cur, new, hi;
int num = pd->numSegments;
jint x0, x1, y0, err;
jint loy;
int ret = JNI_FALSE;
segmentData **segmentTable;
segmentData *seg;
if (pd->state != STATE_SPAN_STARTED) {
if (!initSegmentTable(pd)) {
/* REMIND: - throw exception? */
pd->lowSegment = num;
return JNI_FALSE;
}
}
lo = pd->lowSegment;
cur = pd->curSegment;
hi = pd->hiSegment;
num = pd->numSegments;
loy = pd->loy;
segmentTable = pd->segmentTable;
while (lo < num) {
if (cur < hi) {
seg = segmentTable[cur];
x0 = seg->curx;
if (x0 >= pd->hix) {
cur = hi;
continue;
}
if (x0 < pd->lox) {
x0 = pd->lox;
}
if (pd->evenodd) {
cur += 2;
if (cur <= hi) {
x1 = segmentTable[cur - 1]->curx;
} else {
x1 = pd->hix;
}
} else {
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java