public Graphics2D g2;

Composite defaultComposite;

GeneralPath gpath;

// path for contours so gpath can be closed

GeneralPath auxPath;

boolean openContour;

/// break the shape at the next vertex (next vertex() call is a moveto())

boolean breakShape;

/// coordinates for internal curve calculation

float[] curveCoordX;

float[] curveCoordY;

float[] curveDrawX;

float[] curveDrawY;

int transformCount;

AffineTransform transformStack[] =

new AffineTransform[MATRIX_STACK_DEPTH];

double[] transform = new double[6];

Line2D.Float line = new Line2D.Float();

Ellipse2D.Float ellipse = new Ellipse2D.Float();

Rectangle2D.Float rect = new Rectangle2D.Float();

Arc2D.Float arc = new Arc2D.Float();

protected Color tintColorObject;

protected Color fillColorObject;

public boolean fillGradient;

public Paint fillGradientObject;

protected Stroke strokeObject;

protected Color strokeColorObject;

public boolean strokeGradient;

public Paint strokeGradientObject;

Font fontObject;

//////////////////////////////////////////////////////////////

// INTERNAL

public PGraphicsJava2D() { }

//public void setParent(PApplet parent)

//public void setPrimary(boolean primary)

//public void setPath(String path)

/*

/*

//public void dispose()

@Override

public PSurface createSurface() {

return surface = new PSurfaceAWT(this);

}

/** Returns the java.awt.Graphics2D object used by this renderer. */

@Override

public Object getNative() {

return g2;

}

//////////////////////////////////////////////////////////////

// FRAME

public Graphics2D checkImage() {

if (image == null ||

((BufferedImage) image).getWidth() != width*pixelDensity ||

((BufferedImage) image).getHeight() != height*pixelDensity) {

GraphicsConfiguration gc = null;

if (surface != null) {

Component comp = null; //surface.getComponent();

if (comp == null) {

comp = parent.frame;

}

if (comp != null) {

gc = comp.getGraphicsConfiguration();

}

}

// If not realized (off-screen, i.e the Color Selector Tool), gc will be null.

if (gc == null) {

//System.err.println("GraphicsConfiguration null in initImage()");

GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

gc = ge.getDefaultScreenDevice().getDefaultConfiguration();

}

// Formerly this was broken into separate versions based on offscreen or

// not, but we may as well create a compatible image; it won't hurt, right?

int wide = width * pixelDensity;

int high = height * pixelDensity;

image = gc.createCompatibleImage(wide, high, Transparency.TRANSLUCENT);

//image = surface.getComponent().createImage(width, height);

}

return (Graphics2D) image.getGraphics();

}

@Override

public void beginDraw() {

g2 = checkImage();

// Calling getGraphics() seems to nuke several settings.

// It seems to be re-creating a new Graphics2D object each time.

// https://github.com/processing/processing/issues/3331

if (strokeObject != null) {

g2.setStroke(strokeObject);

}

// https://github.com/processing/processing/issues/2617

if (fontObject != null) {

g2.setFont(fontObject);

}

handleSmooth();

/*

checkSettings();

resetMatrix(); // reset model matrix

vertexCount = 0;

g2.scale(pixelDensity, pixelDensity);

}

/**

protected void handleSmooth() {

if (smooth == 0) {

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_OFF);

g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);

g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,

RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);

} else {

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

if (smooth == 1 || smooth == 3) { // default is bicubic

g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BICUBIC);

} else if (smooth == 2) {

g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BILINEAR);

}

// http://docs.oracle.com/javase/tutorial/2d/text/renderinghints.html

// Oracle Java text anti-aliasing on OS X looks like s*t compared to the

// text rendering with Apple's old Java 6. Below, several attempts to fix:

g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,

RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

// Turns out this is the one that actually makes things work.

// Kerning is still screwed up, however.

g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,

RenderingHints.VALUE_FRACTIONALMETRICS_ON);

}

}

@Override

public void endDraw() {

// hm, mark pixels as changed, because this will instantly do a full

// copy of all the pixels to the surface.. so that's kind of a mess.

//updatePixels();

if (primaryGraphics) {

/*

} else {

// TODO this is probably overkill for most tasks...

loadPixels();

}

// Marks pixels as modified so that the pixels will be updated.

// Also sets mx1/y1/x2/y2 so that OpenGL will pick it up.

setModified();

g2.dispose();

}

/*

//////////////////////////////////////////////////////////////

// SETTINGS

//protected void checkSettings()

@Override

protected void defaultSettings() {

defaultComposite = g2.getComposite();

super.defaultSettings();

}

//protected void reapplySettings()

//////////////////////////////////////////////////////////////

// HINT

@Override

public void hint(int which) {

// take care of setting the hint

super.hint(which);

// Avoid badness when drawing shorter strokes.

// http://code.google.com/p/processing/issues/detail?id=1068

// Unfortunately cannot always be enabled, because it makes the

// stroke in many standard Processing examples really gross.

if (which == ENABLE_STROKE_PURE) {

g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,

RenderingHints.VALUE_STROKE_PURE);

} else if (which == DISABLE_STROKE_PURE) {

g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,

RenderingHints.VALUE_STROKE_DEFAULT);

}

}

//////////////////////////////////////////////////////////////

// SHAPE CREATION

@Override

protected PShape createShapeFamily(int type) {

return new PShape(this, type);

}

@Override

protected PShape createShapePrimitive(int kind, float... p) {

return new PShape(this, kind, p);

}

/*

/*

//////////////////////////////////////////////////////////////

// SHAPES

@Override

public void beginShape(int kind) {

//super.beginShape(kind);

shape = kind;

vertexCount = 0;

curveVertexCount = 0;

// set gpath to null, because when mixing curves and straight

// lines, vertexCount will be set back to zero, so vertexCount == 1

// is no longer a good indicator of whether the shape is new.

// this way, just check to see if gpath is null, and if it isn't

// then just use it to continue the shape.

gpath = null;

auxPath = null;

}

//public boolean edge(boolean e)

//public void normal(float nx, float ny, float nz) {

//public void textureMode(int mode)

@Override

public void texture(PImage image) {

showMethodWarning("texture");

}

@Override

public void vertex(float x, float y) {

curveVertexCount = 0;

//float vertex[];

if (vertexCount == vertices.length) {

float temp[][] = new float[vertexCount<<1][VERTEX_FIELD_COUNT];

System.arraycopy(vertices, 0, temp, 0, vertexCount);

vertices = temp;

//message(CHATTER, "allocating more vertices " + vertices.length);

}

// not everyone needs this, but just easier to store rather

// than adding another moving part to the code...

vertices[vertexCount][X] = x;

vertices[vertexCount][Y] = y;

vertexCount++;

switch (shape) {

case POINTS:

point(x, y);

break;

case LINES:

if ((vertexCount % 2) == 0) {

line(vertices[vertexCount-2][X],

vertices[vertexCount-2][Y], x, y);

}

break;

case TRIANGLES:

if ((vertexCount % 3) == 0) {

triangle(vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y);

}

break;

case TRIANGLE_STRIP:

if (vertexCount >= 3) {

triangle(vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

vertices[vertexCount - 1][X],

vertices[vertexCount - 1][Y],

vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y]);

}

break;

case TRIANGLE_FAN:

if (vertexCount >= 3) {

// This is an unfortunate implementation because the stroke for an

// adjacent triangle will be repeated. However, if the stroke is not

// redrawn, it will replace the adjacent line (when it lines up

// perfectly) or show a faint line (when off by a small amount).

// The alternative would be to wait, then draw the shape as a

// polygon fill, followed by a series of vertices. But that's a

// poor method when used with PDF, DXF, or other recording objects,

// since discrete triangles would likely be preferred.

triangle(vertices[0][X],

vertices[0][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y);

}

break;

case QUAD:

case QUADS:

if ((vertexCount % 4) == 0) {

quad(vertices[vertexCount - 4][X],

vertices[vertexCount - 4][Y],

vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y);

}

break;

case QUAD_STRIP:

// 0---2---4

// | | |

// 1---3---5

if ((vertexCount >= 4) && ((vertexCount % 2) == 0)) {

quad(vertices[vertexCount - 4][X],

vertices[vertexCount - 4][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y,

vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y]);

}

break;

case POLYGON:

if (gpath == null) {

gpath = new GeneralPath();

gpath.moveTo(x, y);

} else if (breakShape) {

gpath.moveTo(x, y);

breakShape = false;

} else {

gpath.lineTo(x, y);

}

break;

}

}

@Override

public void vertex(float x, float y, float z) {

showDepthWarningXYZ("vertex");

}

@Override

public void vertex(float[] v) {

vertex(v[X], v[Y]);

}

@Override

public void vertex(float x, float y, float u, float v) {

showVariationWarning("vertex(x, y, u, v)");

}

@Override

public void vertex(float x, float y, float z, float u, float v) {

showDepthWarningXYZ("vertex");

}

@Override

public void beginContour() {

if (openContour) {

PGraphics.showWarning("Already called beginContour()");

return;

}

// draw contours to auxiliary path so main path can be closed later

GeneralPath contourPath = auxPath;

auxPath = gpath;

gpath = contourPath;

if (contourPath != null) { // first contour does not break

breakShape = true;

}

openContour = true;

}

@Override

public void endContour() {

if (!openContour) {

PGraphics.showWarning("Need to call beginContour() first");

return;

}

// close this contour

if (gpath != null) gpath.closePath();

// switch back to main path

GeneralPath contourPath = gpath;

gpath = auxPath;

auxPath = contourPath;

openContour = false;

}

@Override

public void endShape(int mode) {

if (openContour) { // correct automagically, notify user

endContour();

PGraphics.showWarning("Missing endContour() before endShape()");

}

if (gpath != null) { // make sure something has been drawn

if (shape == POLYGON) {

if (mode == CLOSE) {

gpath.closePath();

}

if (auxPath != null) {

gpath.append(auxPath, false);

}

drawShape(gpath);

}

}

shape = 0;

}

//////////////////////////////////////////////////////////////

// CLIPPING

@Override

protected void clipImpl(float x1, float y1, float x2, float y2) {

g2.setClip(new Rectangle2D.Float(x1, y1, x2 - x1, y2 - y1));

}

@Override

public void noClip() {

g2.setClip(null);

}

//////////////////////////////////////////////////////////////

// BLEND

/**

@Override

protected void blendModeImpl() {

if (blendMode == BLEND) {

g2.setComposite(defaultComposite);

} else {

g2.setComposite(new Composite() {

@Override

public CompositeContext createContext(ColorModel srcColorModel,

ColorModel dstColorModel,

RenderingHints hints) {

return new BlendingContext(blendMode);

}

});

}