Java example source code file (X11Renderer.c)
The X11Renderer.c Java example source code/*
* Copyright (c) 2000, 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 "sun_java2d_x11_X11Renderer.h"
#include "X11SurfaceData.h"
#include "SpanIterator.h"
#include "Trace.h"
#include "ProcessPath.h"
#include "GraphicsPrimitiveMgr.h"
#include <jlong.h>
#ifndef HEADLESS
#define POLYTEMPSIZE (int)(256 / sizeof(XPoint))
#define ABS(n) (((n) < 0) ? -(n) : (n))
#define MAX_SHORT 32767
#define MIN_SHORT (-32768)
#define CLAMP_TO_SHORT(x) (((x) > MAX_SHORT) \
? MAX_SHORT \
: ((x) < MIN_SHORT) \
? MIN_SHORT \
: (x))
#define CLAMP_TO_USHORT(x) (((x) > 65535) ? 65535 : ((x) < 0) ? 0 : (x))
#define DF_MAX_XPNTS 256
typedef struct {
Drawable drawable;
GC gc;
XPoint *pPoints;
XPoint dfPoints[DF_MAX_XPNTS];
jint npoints;
jint maxpoints;
} XDrawHandlerData;
#define XDHD_INIT(PTR, _GC, DRAWABLE) \
do { \
(PTR)->pPoints = (PTR)->dfPoints; \
(PTR)->npoints = 0; \
(PTR)->maxpoints = DF_MAX_XPNTS; \
(PTR)->gc = (_GC); \
(PTR)->drawable = (DRAWABLE); \
} while(0)
#define XDHD_RESET(PTR) \
do { \
(PTR)->npoints = 0; \
} while(0)
#define XDHD_ADD_POINT(PTR, X, Y) \
do { \
XPoint* _pnts = (PTR)->pPoints; \
jint _npnts = (PTR)->npoints; \
if (_npnts >= (PTR)->maxpoints) { \
jint newMax = (PTR)->maxpoints*2; \
if ((PTR)->pPoints == (PTR)->dfPoints) { \
(PTR)->pPoints = (XPoint*)malloc(newMax*sizeof(XPoint)); \
memcpy((PTR)->pPoints, _pnts, _npnts*sizeof(XPoint)); \
} else { \
(PTR)->pPoints = (XPoint*)realloc( \
_pnts, newMax*sizeof(XPoint)); \
} \
_pnts = (PTR)->pPoints; \
(PTR)->maxpoints = newMax; \
} \
_pnts += _npnts; \
_pnts->x = X; \
_pnts->y = Y; \
(PTR)->npoints = _npnts + 1; \
} while(0)
#define XDHD_FREE_POINTS(PTR) \
do { \
if ((PTR)->pPoints != (PTR)->dfPoints) { \
free((PTR)->pPoints); \
} \
} while(0)
static void
awt_drawArc(JNIEnv * env, jint drawable, GC xgc,
int x, int y, int w, int h,
int startAngle, int endAngle,
int filled)
{
int s, e;
if (w < 0 || h < 0) {
return;
}
if (endAngle >= 360 || endAngle <= -360) {
s = 0;
e = 360 * 64;
} else {
s = (startAngle % 360) * 64;
e = endAngle * 64;
}
if (filled == 0) {
XDrawArc(awt_display, drawable, xgc, x, y, w, h, s, e);
} else {
XFillArc(awt_display, drawable, xgc, x, y, w, h, s, e);
}
}
/*
* Copy vertices from xcoordsArray and ycoordsArray to a buffer
* of XPoint structures, translating by transx and transy and
* collapsing empty segments out of the list as we go.
* The number of points to be converted should be guaranteed
* to be more than 2 by the caller and is stored at *pNpoints.
* The resulting number of uncollapsed unique translated vertices
* will be stored back into the location *pNpoints.
* The points pointer is guaranteed to be pointing to an area of
* memory large enough for POLYTEMPSIZE points and a larger
* area of memory is allocated (and returned) if that is not enough.
*/
static XPoint *
transformPoints(JNIEnv * env,
jintArray xcoordsArray, jintArray ycoordsArray,
jint transx, jint transy,
XPoint * points, int *pNpoints, int close)
{
int npoints = *pNpoints;
jint *xcoords, *ycoords;
xcoords = (jint *)
(*env)->GetPrimitiveArrayCritical(env, xcoordsArray, NULL);
if (xcoords == NULL) {
return 0;
}
ycoords = (jint *)
(*env)->GetPrimitiveArrayCritical(env, ycoordsArray, NULL);
if (ycoords == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, xcoordsArray, xcoords,
JNI_ABORT);
return 0;
}
if (close) {
close = (xcoords[npoints - 1] != xcoords[0] ||
ycoords[npoints - 1] != ycoords[0]);
if (close) {
npoints++;
}
}
if (npoints > POLYTEMPSIZE) {
points = (XPoint *) malloc(sizeof(XPoint) * npoints);
}
if (points != NULL) {
int in, out;
int oldx = CLAMP_TO_SHORT(xcoords[0] + transx);
int oldy = CLAMP_TO_SHORT(ycoords[0] + transy);
points[0].x = oldx;
points[0].y = oldy;
if (close) {
npoints--;
}
for (in = 1, out = 1; in < npoints; in++) {
int newx = CLAMP_TO_SHORT(xcoords[in] + transx);
int newy = CLAMP_TO_SHORT(ycoords[in] + transy);
if (newx != oldx || newy != oldy) {
points[out].x = newx;
points[out].y = newy;
out++;
oldx = newx;
oldy = newy;
}
}
if (out == 1) {
points[1].x = oldx;
points[1].y = oldy;
out = 2;
} else if (close) {
points[out++] = points[0];
}
*pNpoints = out;
}
(*env)->ReleasePrimitiveArrayCritical(env, xcoordsArray, xcoords,
JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, ycoordsArray, ycoords,
JNI_ABORT);
return points;
}
#endif /* !HEADLESS */
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawLine
* Signature: (IJIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawLine
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x1, jint y1, jint x2, jint y2)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
CLAMP_TO_SHORT(x1), CLAMP_TO_SHORT(y1),
CLAMP_TO_SHORT(x2), CLAMP_TO_SHORT(y2));
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawRect
* Signature: (IJIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawRect
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL || w < 0 || h < 0) {
return;
}
if (w < 2 || h < 2) {
/* REMIND: This optimization assumes thin lines. */
/*
* This optimization not only simplifies the processing
* of a particular degenerate case, but it protects against
* the anomalies of various X11 implementations that draw
* nothing for degenerate Polygons and Rectangles.
*/
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
CLAMP_TO_SHORT(x), CLAMP_TO_SHORT(y),
CLAMP_TO_USHORT(w+1), CLAMP_TO_USHORT(h+1));
} else {
XDrawRectangle(awt_display, xsdo->drawable, (GC) xgc,
CLAMP_TO_SHORT(x), CLAMP_TO_SHORT(y),
CLAMP_TO_USHORT(w), CLAMP_TO_USHORT(h));
}
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawRoundRect
* Signature: (IJIIIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawRoundRect
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h,
jint arcW, jint arcH)
{
#ifndef HEADLESS
long ty1, ty2, tx1, tx2, cx, cy, cxw, cyh,
halfW, halfH, leftW, rightW, topH, bottomH;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL || w < 0 || h < 0) {
return;
}
arcW = ABS(arcW);
arcH = ABS(arcH);
if (arcW > w) {
arcW = w;
}
if (arcH > h) {
arcH = h;
}
if (arcW == 0 || arcH == 0) {
Java_sun_java2d_x11_X11Renderer_XDrawRect(env, xr, pXSData, xgc,
x, y, w, h);
return;
}
halfW = (arcW / 2);
halfH = (arcH / 2);
/* clamp to short bounding box of round rectangle */
cx = CLAMP_TO_SHORT(x);
cy = CLAMP_TO_SHORT(y);
cxw = CLAMP_TO_SHORT(x + w);
cyh = CLAMP_TO_SHORT(y + h);
/* clamp to short coordinates of lines */
tx1 = CLAMP_TO_SHORT(x + halfW + 1);
tx2 = CLAMP_TO_SHORT(x + w - halfW - 1);
ty1 = CLAMP_TO_SHORT(y + halfH + 1);
ty2 = CLAMP_TO_SHORT(y + h - halfH - 1);
/*
* recalculate heightes and widthes of round parts
* to minimize distortions in visible area
*/
leftW = (tx1 - cx) * 2;
rightW = (cxw - tx2) * 2;
topH = (ty1 - cy) * 2;
bottomH = (cyh - ty2) * 2;
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cx, cy, leftW, topH,
90, 90, JNI_FALSE);
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cxw - rightW, cy, rightW, topH,
0, 90, JNI_FALSE);
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cx, cyh - bottomH, leftW, bottomH,
180, 90, JNI_FALSE);
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cxw - rightW, cyh - bottomH, rightW, bottomH,
270, 90, JNI_FALSE);
if (tx1 <= tx2) {
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
tx1, cy, tx2, cy);
if (h > 0) {
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
tx1, cyh, tx2, cyh);
}
}
if (ty1 <= ty2) {
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
cx, ty1, cx, ty2);
if (w > 0) {
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
cxw, ty1, cxw, ty2);
}
}
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawOval
* Signature: (IJIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawOval
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (w < 2 || h < 2) {
/*
* Fix for 4205762 - 1x1 ovals do not draw on Ultra1, Creator3d
* (related to 4411814 on Windows platform)
* Really small ovals degenerate to simple rectangles as they
* have no curvature or enclosed area. Use XFillRectangle
* for speed and to deal better with degenerate sizes.
*/
if (w >= 0 && h >= 0) {
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
x, y, w+1, h+1);
}
} else {
awt_drawArc(env, xsdo->drawable, (GC) xgc,
x, y, w, h, 0, 360, JNI_FALSE);
}
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawArc
* Signature: (IJIIIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawArc
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h,
jint angleStart, jint angleExtent)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
awt_drawArc(env, xsdo->drawable, (GC) xgc,
x, y, w, h, angleStart, angleExtent, JNI_FALSE);
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawPoly
* Signature: (IJII[I[IIZ)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawPoly
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint transx, jint transy,
jintArray xcoordsArray, jintArray ycoordsArray, jint npoints,
jboolean isclosed)
{
#ifndef HEADLESS
XPoint pTmp[POLYTEMPSIZE], *points;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, xcoordsArray) || JNU_IsNull(env, ycoordsArray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if ((*env)->GetArrayLength(env, ycoordsArray) < npoints ||
(*env)->GetArrayLength(env, xcoordsArray) < npoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array");
return;
}
if (npoints < 2) {
return;
}
points = transformPoints(env, xcoordsArray, ycoordsArray, transx, transy,
pTmp, (int *)&npoints, isclosed);
if (points != 0) {
if (npoints == 2) {
/*
* Some X11 implementations fail to draw anything for
* simple 2 point polygons where the vertices are the
* same point even though this violates the X11
* specification. For simplicity we will dispatch all
* 2 point polygons through XDrawLine even if they are
* non-degenerate as this may invoke less processing
* down the line than a Poly primitive anyway.
*/
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
points[0].x, points[0].y,
points[1].x, points[1].y);
} else {
XDrawLines(awt_display, xsdo->drawable, (GC) xgc,
points, npoints, CoordModeOrigin);
}
if (points != pTmp) {
free(points);
}
X11SD_DirectRenderNotify(env, xsdo);
}
#endif /* !HEADLESS */
}
static void storeLine(DrawHandler* hnd,
jint x0, jint y0, jint x1, jint y1)
{
#ifndef HEADLESS
XDrawHandlerData* dhnd = (XDrawHandlerData*)(hnd->pData);
XDHD_ADD_POINT(dhnd, x0, y0);
XDHD_ADD_POINT(dhnd, x1, y1);
#endif /* !HEADLESS */
}
static void storePoint(DrawHandler* hnd, jint x0, jint y0) {
#ifndef HEADLESS
XDrawHandlerData* dhnd = (XDrawHandlerData*)(hnd->pData);
XDHD_ADD_POINT(dhnd, x0, y0);
#endif /* !HEADLESS */
}
static void drawSubPath(ProcessHandler* hnd) {
#ifndef HEADLESS
XDrawHandlerData* dhnd = (XDrawHandlerData*)(hnd->dhnd->pData);
XPoint *points = dhnd->pPoints;
switch (dhnd->npoints) {
case 0:
/* No-op */
break;
case 1:
/* Draw the single pixel */
XFillRectangle(awt_display, dhnd->drawable, dhnd->gc,
points[0].x, points[0].y, 1, 1);
break;
case 2:
/*
* The XDrawLines method for some X11 implementations
* fails to draw anything for simple 2 point polygons
* where the vertices are the same point even though
* this violates the X11 specification. For simplicity
* we will dispatch all 2 point polygons through XDrawLine
* even if they are non-degenerate as this may invoke
* less processing down the line than a poly primitive anyway.
*/
XDrawLine(awt_display, dhnd->drawable, dhnd->gc,
points[0].x, points[0].y,
points[1].x, points[1].y);
break;
default:
/* Draw the entire polyline */
XDrawLines(awt_display, dhnd->drawable, dhnd->gc, points,
dhnd->npoints, CoordModeOrigin);
break;
}
XDHD_RESET(dhnd);
#endif /* !HEADLESS */
}
static void drawScanline(DrawHandler* hnd, jint x0, jint x1, jint y0)
{
#ifndef HEADLESS
XDrawHandlerData* dhnd = (XDrawHandlerData*)(hnd->pData);
XDrawLine(awt_display, dhnd->drawable, dhnd->gc, x0, y0, x1, y0);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDoPath
* Signature: (Lsun/java2d/SunGraphics2D;JJIILjava/awt/geom/Path2D/Float;Z)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_x11_X11Renderer_XDoPath
(JNIEnv *env, jobject self, jobject sg2d, jlong pXSData, jlong xgc,
jint transX, jint transY, jobject p2df, jboolean isFill)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
jarray typesArray;
jobject pointArray;
jarray coordsArray;
jint numTypes;
jint fillRule;
jint maxCoords;
jbyte *types;
jfloat *coords;
XDrawHandlerData dHData;
DrawHandler drawHandler = {
NULL, NULL, NULL,
MIN_SHORT, MIN_SHORT, MAX_SHORT, MAX_SHORT,
0, 0, 0, 0,
NULL
};
PHStroke stroke;
jboolean ok = JNI_TRUE;
if (xsdo == NULL) {
return;
}
if (isFill) {
fillRule = (*env)->GetIntField(env, p2df, path2DWindingRuleID);
}
typesArray = (jarray)(*env)->GetObjectField(env, p2df, path2DTypesID);
coordsArray = (jarray)(*env)->GetObjectField(env, p2df,
path2DFloatCoordsID);
if (coordsArray == NULL) {
JNU_ThrowNullPointerException(env, "coordinates array");
return;
}
numTypes = (*env)->GetIntField(env, p2df, path2DNumTypesID);
if ((*env)->GetArrayLength(env, typesArray) < numTypes) {
JNU_ThrowArrayIndexOutOfBoundsException(env, "types array");
return;
}
XDHD_INIT(&dHData, (GC)xgc, xsdo->drawable);
drawHandler.pData = &dHData;
stroke = (((*env)->GetIntField(env, sg2d, sg2dStrokeHintID) ==
sunHints_INTVAL_STROKE_PURE)
? PH_STROKE_PURE
: PH_STROKE_DEFAULT);
maxCoords = (*env)->GetArrayLength(env, coordsArray);
coords = (jfloat*)
(*env)->GetPrimitiveArrayCritical(env, coordsArray, NULL);
if (coords != NULL) {
types = (jbyte*)
(*env)->GetPrimitiveArrayCritical(env, typesArray, NULL);
if (types != NULL) {
if (isFill) {
drawHandler.pDrawScanline = &drawScanline;
ok = doFillPath(&drawHandler,
transX, transY,
coords, maxCoords,
types, numTypes,
stroke, fillRule);
} else {
drawHandler.pDrawLine = &storeLine;
drawHandler.pDrawPixel = &storePoint;
ok = doDrawPath(&drawHandler, &drawSubPath,
transX, transY,
coords, maxCoords,
types, numTypes,
stroke);
}
(*env)->ReleasePrimitiveArrayCritical(env, typesArray, types,
JNI_ABORT);
}
(*env)->ReleasePrimitiveArrayCritical(env, coordsArray, coords,
JNI_ABORT);
if (!ok) {
JNU_ThrowArrayIndexOutOfBoundsException(env, "coords array");
}
}
XDHD_FREE_POINTS(&dHData);
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillRect
* Signature: (IJIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillRect
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
CLAMP_TO_SHORT(x), CLAMP_TO_SHORT(y),
CLAMP_TO_USHORT(w), CLAMP_TO_USHORT(h));
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillRoundRect
* Signature: (IJIIIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillRoundRect
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h,
jint arcW, jint arcH)
{
#ifndef HEADLESS
long ty1, ty2, tx1, tx2, cx, cy, cxw, cyh,
halfW, halfH, leftW, rightW, topH, bottomH;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL || w <= 0 || h <= 0) {
return;
}
arcW = ABS(arcW);
arcH = ABS(arcH);
if (arcW > w) {
arcW = w;
}
if (arcH > h) {
arcH = h;
}
if (arcW == 0 || arcH == 0) {
Java_sun_java2d_x11_X11Renderer_XFillRect(env, xr, pXSData, xgc,
x, y, w, h);
return;
}
halfW = (arcW / 2);
halfH = (arcH / 2);
/* clamp to short bounding box of round rectangle */
cx = CLAMP_TO_SHORT(x);
cy = CLAMP_TO_SHORT(y);
cxw = CLAMP_TO_SHORT(x + w);
cyh = CLAMP_TO_SHORT(y + h);
/* clamp to short coordinates of lines */
tx1 = CLAMP_TO_SHORT(x + halfW + 1);
tx2 = CLAMP_TO_SHORT(x + w - halfW - 1);
ty1 = CLAMP_TO_SHORT(y + halfH + 1);
ty2 = CLAMP_TO_SHORT(y + h - halfH - 1);
/*
* recalculate heightes and widthes of round parts
* to minimize distortions in visible area
*/
leftW = (tx1 - cx) * 2;
rightW = (cxw - tx2) * 2;
topH = (ty1 - cy) * 2;
bottomH = (cyh - ty2) * 2;
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cx, cy, leftW, topH,
90, 90, JNI_TRUE);
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cxw - rightW, cy, rightW, topH,
0, 90, JNI_TRUE);
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cx, cyh - bottomH, leftW, bottomH,
180, 90, JNI_TRUE);
awt_drawArc(env, xsdo->drawable, (GC) xgc,
cxw - rightW, cyh - bottomH, rightW, bottomH,
270, 90, JNI_TRUE);
if (tx1 < tx2) {
if (cy < ty1) {
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
tx1, cy, tx2 - tx1, ty1 - cy);
}
if (ty2 < cyh) {
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
tx1, ty2, tx2 - tx1, cyh - ty2);
}
}
if (ty1 < ty2) {
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
cx, ty1, cxw - cx, ty2 - ty1);
}
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillOval
* Signature: (IJIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillOval
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (w < 3 || h < 3) {
/*
* Fix for 4205762 - 1x1 ovals do not draw on Ultra1, Creator3d
* (related to 4411814 on Windows platform)
* Most X11 servers drivers have poor rendering
* for thin ellipses and the rendering is most strikingly
* different from our theoretical arcs. Ideally we should
* trap all ovals less than some fairly large size and
* try to draw aesthetically pleasing ellipses, but that
* would require considerably more work to get the corresponding
* drawArc variants to match pixel for pixel.
* Thin ovals of girth 1 pixel are simple rectangles.
* Thin ovals of girth 2 pixels are simple rectangles with
* potentially smaller lengths. Determine the correct length
* by calculating .5*.5 + scaledlen*scaledlen == 1.0 which
* means that scaledlen is the sqrt(0.75). Scaledlen is
* relative to the true length (w or h) and needs to be
* adjusted by half a pixel in different ways for odd or
* even lengths.
*/
#define SQRT_3_4 0.86602540378443864676
if (w > 2 && h > 1) {
int adjw = (int) ((SQRT_3_4 * w - ((w&1)-1)) * 0.5);
adjw = adjw * 2 + (w&1);
x += (w-adjw)/2;
w = adjw;
} else if (h > 2 && w > 1) {
int adjh = (int) ((SQRT_3_4 * h - ((h&1)-1)) * 0.5);
adjh = adjh * 2 + (h&1);
y += (h-adjh)/2;
h = adjh;
}
#undef SQRT_3_4
if (w > 0 && h > 0) {
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc, x, y, w, h);
}
} else {
awt_drawArc(env, xsdo->drawable, (GC) xgc,
x, y, w, h, 0, 360, JNI_TRUE);
}
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillArc
* Signature: (IJIIIIII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillArc
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint x, jint y, jint w, jint h,
jint angleStart, jint angleExtent)
{
#ifndef HEADLESS
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
awt_drawArc(env, xsdo->drawable, (GC) xgc,
x, y, w, h, angleStart, angleExtent, JNI_TRUE);
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillPoly
* Signature: (IJII[I[II)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillPoly
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint transx, jint transy,
jintArray xcoordsArray, jintArray ycoordsArray, jint npoints)
{
#ifndef HEADLESS
XPoint pTmp[POLYTEMPSIZE], *points;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, xcoordsArray) || JNU_IsNull(env, ycoordsArray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if ((*env)->GetArrayLength(env, ycoordsArray) < npoints ||
(*env)->GetArrayLength(env, xcoordsArray) < npoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array");
return;
}
if (npoints < 3) {
return;
}
points = transformPoints(env, xcoordsArray, ycoordsArray, transx, transy,
pTmp, (int *)&npoints, JNI_FALSE);
if (points != 0) {
if (npoints > 2) {
XFillPolygon(awt_display, xsdo->drawable, (GC) xgc,
points, npoints, Complex, CoordModeOrigin);
X11SD_DirectRenderNotify(env, xsdo);
}
if (points != pTmp) {
free(points);
}
}
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillSpans
* Signature: (IJLsun/java2d/pipe/SpanIterator;JII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillSpans
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jobject si, jlong pIterator,
jint transx, jint transy)
{
#ifndef HEADLESS
SpanIteratorFuncs *pFuncs = (SpanIteratorFuncs *) jlong_to_ptr(pIterator);
void *srData;
jint x, y, w, h;
jint spanbox[4];
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, si)) {
JNU_ThrowNullPointerException(env, "span iterator");
return;
}
if (pFuncs == NULL) {
JNU_ThrowNullPointerException(env, "native iterator not supplied");
return;
}
srData = (*pFuncs->open)(env, si);
while ((*pFuncs->nextSpan)(srData, spanbox)) {
x = spanbox[0] + transx;
y = spanbox[1] + transy;
w = spanbox[2] - spanbox[0];
h = spanbox[3] - spanbox[1];
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
CLAMP_TO_SHORT(x), CLAMP_TO_SHORT(y),
CLAMP_TO_USHORT(w), CLAMP_TO_USHORT(h));
}
(*pFuncs->close)(env, srData);
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: devCopyArea
* Signature: (Lsun/java2d/SurfaceData;IIIIII)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_x11_X11Renderer_devCopyArea
(JNIEnv *env, jobject xr,
jlong xsd, jlong gc,
jint srcx, jint srcy,
jint dstx, jint dsty,
jint width, jint height)
{
#ifndef HEADLESS
X11SDOps *xsdo;
GC xgc;
xsdo = (X11SDOps *)jlong_to_ptr(xsd);
if (xsdo == NULL) {
return;
}
xgc = (GC)gc;
if (xgc == NULL) {
return;
}
XCopyArea(awt_display, xsdo->drawable, xsdo->drawable, xgc,
srcx, srcy, width, height, dstx, dsty);
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
Other Java examples (source code examples)Here is a short list of links related to this Java X11Renderer.c source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
