Skip to content

R
riscv-gcc-1
Commit 1fe2d5fb by Graydon Hoare Committed by Graydon Hoare
Options

GdkGraphics2D.java, [...]: New files. 

2003-09-17  Graydon Hoare  <graydon@redhat.com>

	* gnu/java/awt/peer/gtk/GdkGraphics2D.java,
	gnu/java/awt/peer/gtk/GdkPixbufDecoder.java,
	jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics2D.c,
	jni/gtk-peer/gnu_java_awt_peer_gtk_GdkPixbufDecoder.c:
	New files.

From-SVN: r71475
parent eeae7b41
Showing with 2676 additions and 0 deletions
libjava/ChangeLog
2003-09-17 Graydon Hoare <graydon@redhat.com>
* gnu/java/awt/peer/gtk/GdkGraphics2D.java,
gnu/java/awt/peer/gtk/GdkPixbufDecoder.java,
jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics2D.c,
jni/gtk-peer/gnu_java_awt_peer_gtk_GdkPixbufDecoder.c:
New files.
2003-09-16 Graydon Hoare <graydon@redhat.com> 2003-09-16 Graydon Hoare <graydon@redhat.com>
* java/awt/BufferedImage.java (setData): Support non-component * java/awt/BufferedImage.java (setData): Support non-component
......
libjava/gnu/java/awt/peer/gtk/GdkGraphics2D.java 0 → 100644
/* GdkGraphics2D.java
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.awt.peer.gtk;
import java.awt.*;
import java.awt.geom.*;
import java.awt.font.*;
import java.awt.color.*;
import java.awt.image.*;
import java.awt.image.renderable.*;
import java.text.AttributedCharacterIterator;
import java.util.Map;
import java.lang.Integer;
import gnu.classpath.Configuration;
public class GdkGraphics2D extends Graphics2D
{
//////////////////////////////////////
////// State Management Methods //////
//////////////////////////////////////
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("gtkpeer");
}
initStaticState ();
}
native static void initStaticState ();
private final int native_state = GtkGenericPeer.getUniqueInteger();
private Paint paint;
private Stroke stroke;
private Color fg;
private Color bg;
private Shape clip;
private AffineTransform transform;
private GtkComponentPeer component;
private GdkFont font;
native private int[] initState (GtkComponentPeer component);
native private void initState (int width, int height);
native private void copyState (GdkGraphics2D g);
native public void dispose ();
public void finalize ()
{
dispose();
}
public Graphics create ()
{
return new GdkGraphics2D (this);
}
public Graphics create (int x, int y, int width, int height)
{
return new GdkGraphics2D (width, height);
}
GdkGraphics2D (GdkGraphics2D g)
{
paint = g.paint;
stroke = g.stroke;
if (g.fg.getAlpha() != -1)
fg = new Color (g.fg.getRed (), g.fg.getGreen (),
g.fg.getBlue (), g.fg.getAlpha ());
else
fg = new Color (g.fg.getRGB ());
if (g.bg.getAlpha() != -1)
bg = new Color(g.bg.getRed (), g.bg.getGreen (),
g.bg.getBlue (), g.bg.getAlpha ());
else
bg = new Color (g.bg.getRGB ());
if (g.clip == null)
clip = null;
else
clip = new Rectangle (g.getClipBounds ());
if (g.transform == null)
transform = null;
else
transform = new AffineTransform (g.transform);
component = g.component;
copyState (g);
setColor (fg);
setClip (clip);
setTransform (transform);
}
GdkGraphics2D (int width, int height)
{
initState (width, height);
bg = Color.black;
fg = Color.black;
transform = new AffineTransform ();
}
GdkGraphics2D (GtkComponentPeer component)
{
this.component = component;
int rgb[] = initState (component);
fg = new Color (rgb[0], rgb[1], rgb[2]);
bg = new Color (rgb[3], rgb[4], rgb[5]);
transform = new AffineTransform ();
}
////////////////////////////////////
////// Native Drawing Methods //////
////////////////////////////////////
// GDK drawing methods
private native void gdkDrawDrawable (GdkGraphics2D other, int x, int y);
// drawing utility methods
private native void drawPixels (int pixels[], int w, int h, int stride);
private native void setTexturePixels (int pixels[], int w, int h, int stride);
private native void setGradient (double x1, double y1,
double x2, double y2,
int r1, int g1, int b1, int a1,
int r2, int g2, int b2, int a2,
boolean cyclic);
// simple passthroughs to cairo
private native void cairoSave ();
private native void cairoRestore ();
private native void cairoSetMatrix (double m00, double m10,
double m01, double m11,
double m02, double m12);
private native void cairoSetOperator (int cairoOperator);
private native void cairoSetRGBColor (double red, double green, double blue);
private native void cairoSetAlpha (double alpha);
private native void cairoSetFillRule (int cairoFillRule);
private native void cairoSetLineWidth (double width);
private native void cairoSetLineCap (int cairoLineCap);
private native void cairoSetLineJoin (int cairoLineJoin);
private native void cairoSetDash (double dashes[], int ndash, double offset);
private native void cairoSetMiterLimit (double limit);
private native void cairoTranslate (double tx, double ty);
private native void cairoScale (double sx, double sy);
private native void cairoRotate (double angle);
private native void cairoNewPath ();
private native void cairoMoveTo (double x, double y);
private native void cairoLineTo (double x, double y);
private native void cairoCurveTo (double x1, double y1,
double x2, double y2,
double x3, double y3);
private native void cairoRelMoveTo (double dx, double dy);
private native void cairoRelLineTo (double dx, double dy);
private native void cairoRelCurveTo (double dx1, double dy1,
double dx2, double dy2,
double dx3, double dy3);
private native void cairoRectangle (double x, double y,
double width, double height);
private native void cairoClosePath ();
private native void cairoStroke ();
private native void cairoFill ();
private native void cairoClip ();
/////////////////////////////////////////////
////// General Drawing Support Methods //////
/////////////////////////////////////////////
double x;
double y;
private void setPos (double nx, double ny)
{
x = nx;
y = ny;
}
private void walkPath(PathIterator p)
{
double coords[] = new double[6];
cairoSetFillRule (p.getWindingRule ());
for ( ; ! p.isDone (); p.next())
{
int seg = p.currentSegment (coords);
switch(seg)
{
case PathIterator.SEG_MOVETO:
setPos(coords[0], coords[1]);
cairoMoveTo (coords[0], coords[1]);
break;
case PathIterator.SEG_LINETO:
setPos(coords[0], coords[1]);
cairoLineTo (coords[0], coords[1]);
break;
case PathIterator.SEG_QUADTO:
// splitting a quadratic bezier into a cubic:
// see: http://pfaedit.sourceforge.net/bezier.html
double x1 = x + (2.0/3.0) * (coords[0] - x);
double y1 = y + (2.0/3.0) * (coords[1] - y);
double x2 = x1 + (1.0/3.0) * (coords[2] - x);
double y2 = y1 + (1.0/3.0) * (coords[3] - y);
setPos(coords[2], coords[3]);
cairoCurveTo (x1, y1,
x2, y2,
coords[2], coords[3]);
break;
case PathIterator.SEG_CUBICTO:
setPos(coords[4], coords[5]);
cairoCurveTo (coords[0], coords[1],
coords[2], coords[3],
coords[4], coords[5]);
break;
case PathIterator.SEG_CLOSE:
cairoClosePath ();
break;
}
}
}
//////////////////////////////////////////////////
////// Implementation of Graphics2D Methods //////
//////////////////////////////////////////////////
public void draw (Shape s)
{
if (stroke != null &&
!(stroke instanceof BasicStroke))
{
fill (stroke.createStrokedShape (s));
return;
}
cairoSave ();
cairoNewPath ();
if (s instanceof Rectangle2D)
{
Rectangle2D r = (Rectangle2D)s;
cairoRectangle (r.getX (), r.getY (), r.getWidth (), r.getHeight ());
}
else
walkPath (s.getPathIterator (null));
cairoStroke ();
cairoRestore ();
}
public void fill(Shape s)
{
cairoSave();
cairoNewPath ();
if (s instanceof Rectangle2D)
{
Rectangle2D r = (Rectangle2D)s;
cairoRectangle (r.getX (), r.getY (), r.getWidth (), r.getHeight ());
}
else
walkPath (s.getPathIterator (null));
cairoFill ();
cairoRestore ();
}
public void clip (Shape s)
{
clip = s;
cairoNewPath ();
if (s instanceof Rectangle2D)
{
Rectangle2D r = (Rectangle2D)s;
cairoRectangle (r.getX (), r.getY (),
r.getWidth (), r.getHeight ());
}
else
walkPath (s.getPathIterator (null));
cairoClosePath ();
cairoClip ();
}
public Paint getPaint ()
{
return paint;
}
public AffineTransform getTransform ()
{
return transform;
}
public void setPaint (Paint p)
{
paint = p;
if (paint instanceof Color)
{
setColor ((Color) paint);
}
else if (paint instanceof TexturePaint)
{
TexturePaint tp = (TexturePaint) paint;
BufferedImage img = tp.getImage ();
int pixels[] = img.getRGB(0, 0, img.getWidth (),
img.getHeight (), null,
0, img.getWidth ());
setTexturePixels (pixels, img.getWidth (),
img.getHeight (), img.getWidth ());
}
else if (paint instanceof GradientPaint)
{
GradientPaint gp = (GradientPaint) paint;
Point2D p1 = gp.getPoint1 ();
Point2D p2 = gp.getPoint2 ();
Color c1 = gp.getColor1 ();
Color c2 = gp.getColor2 ();
setGradient (p1.getX (), p1.getY (),
p2.getX (), p2.getY (),
c1.getRed (), c1.getGreen (),
c1.getBlue (), c1.getAlpha (),
c2.getRed (), c2.getGreen (),
c2.getBlue (), c2.getAlpha (),
gp.isCyclic ());
}
else
throw new java.lang.UnsupportedOperationException ();
}
public void setTransform (AffineTransform tx)
{
transform = tx;
if (transform != null)
{
double m[] = new double[6];
transform.getMatrix (m);
cairoSetMatrix (m[0], m[1], m[2], m[3], m[4], m[5]);
}
}
public void transform (AffineTransform tx)
{
if (transform == null)
transform = new AffineTransform (tx);
else
transform.concatenate (tx);
setTransform (transform);
}
public void rotate(double theta)
{
if (transform != null)
transform.rotate (theta);
cairoRotate (theta);
}
public void rotate(double theta, double x, double y)
{
if (transform != null)
transform.rotate (theta, x, y);
cairoTranslate (x, y);
cairoRotate (theta);
cairoTranslate (-x, -y);
}
public void scale(double sx, double sy)
{
if (transform != null)
transform.scale (sx, sy);
cairoScale (sx, sy);
}
public void translate (double tx, double ty)
{
if (transform != null)
transform.translate (tx, ty);
cairoTranslate (tx, ty);
}
public void translate (int x, int y)
{
translate ((double) x, (double) y);
}
public Stroke getStroke()
{
return stroke;
}
public void setStroke (Stroke st)
{
stroke = st;
if (stroke instanceof BasicStroke)
{
BasicStroke bs = (BasicStroke) stroke;
cairoSetLineCap (bs.getEndCap());
cairoSetLineWidth (bs.getLineWidth());
cairoSetLineJoin (bs.getLineJoin());
cairoSetMiterLimit (bs.getMiterLimit());
float dashes[] = bs.getDashArray();
if (dashes != null)
{
double double_dashes[] = new double[dashes.length];
for (int i = 0; i < dashes.length; i++)
double_dashes[i] = dashes[i];
cairoSetDash (double_dashes, double_dashes.length,
(double) bs.getDashPhase ());
}
}
}
////////////////////////////////////////////////
////// Implementation of Graphics Methods //////
////////////////////////////////////////////////
public void setPaintMode ()
{
setComposite (java.awt.AlphaComposite.Xor);
}
public void setXORMode (Color c)
{
setComposite (new BitwiseXorComposite (c));
}
public void setColor (Color c)
{
fg = c;
cairoSetRGBColor (fg.getRed() / 255.0,
fg.getGreen() / 255.0,
fg.getBlue() / 255.0);
cairoSetAlpha ((fg.getAlpha() & 255) / 255.0);
}
public Color getColor ()
{
return fg;
}
public void clipRect (int x, int y, int width, int height)
{
// this is *slightly* different than all the other clip functions: it
// intersects the clip area with the new clip rectangle. obviously. of
// course, since Shape doesn't *have* any way of intersecting with a
// rectangle, we will promote the current clipping region to its
// bounding rectangle and then intersect with that.
if (clip == null)
{
cairoNewPath ();
cairoRectangle (x, y, width, height);
cairoClosePath ();
cairoClip ();
clip = new Rectangle (x, y, width, height);
}
else
{
clip (clip.getBounds ().intersection
(new Rectangle (x, y, width, height)));
}
}
public Shape getClip ()
{
return clip;
}
public Rectangle getClipBounds ()
{
if (clip == null)
return null;
else
return clip.getBounds ();
}
public void setClip (int x, int y, int width, int height)
{
cairoNewPath ();
cairoRectangle (x, y, width, height);
cairoClosePath ();
cairoClip ();
clip = new Rectangle (x, y, width, height);
}
public void setClip (Shape s)
{
clip (s);
}
public void draw3DRect(int x, int y, int width,
int height, boolean raised)
{
Color std = fg;
Color light = std.brighter();
Color dark = std.darker();
if (!raised)
{
Color t = light;
light = dark;
dark = t;
}
double x1 = (double) x;
double x2 = (double) x + width;
double y1 = (double) y;
double y2 = (double) y + height;
cairoSave ();
cairoNewPath ();
setColor (light);
cairoMoveTo (x1, y1);
cairoLineTo (x2, y1);
cairoLineTo (x2, y2);
cairoStroke ();
cairoNewPath ();
setColor (dark);
cairoMoveTo (x1, y1);
cairoLineTo (x1, y2);
cairoLineTo (x2, y2);
cairoStroke ();
cairoRestore ();
setColor (std);
}
public void fill3DRect(int x, int y, int width,
int height, boolean raised)
{
double step = 1.0;
if (stroke != null && stroke instanceof BasicStroke)
{
BasicStroke bs = (BasicStroke) stroke;
step = bs.getLineWidth();
}
Color bright = fg.brighter ();
Color dark = fg.darker ();
draw3DRect (x, y, width, height, raised);
cairoSave ();
cairoTranslate (step/2.0, step/2.0);
cairoNewPath ();
cairoRectangle ((double) x, (double) y,
((double) width) - step,
((double) height) - step );
cairoClosePath ();
cairoFill ();
cairoRestore ();
}
public void drawRect (int x, int y, int width, int height)
{
draw(new Rectangle (x, y, width, height));
}
public void fillRect (int x, int y, int width, int height)
{
fill(new Rectangle (x, y, width, height));
}
public void clearRect (int x, int y, int width, int height)
{
cairoSave ();
cairoSetRGBColor (bg.getRed() / 255.0,
bg.getGreen() / 255.0,
bg.getBlue() / 255.0);
cairoSetAlpha (1.0);
cairoNewPath ();
cairoRectangle (x, y, width, height);
cairoClosePath ();
cairoFill ();
cairoRestore ();
}
public void setBackground(Color c)
{
bg = c;
}
public Color getBackground()
{
return bg;
}
private void doPolygon(int[] xPoints, int[] yPoints, int nPoints,
boolean close, boolean fill)
{
if (nPoints < 1)
return;
GeneralPath gp = new GeneralPath ();
gp.moveTo ((float)xPoints[0], (float)yPoints[0]);
for (int i = 1; i < nPoints; i++)
gp.lineTo ((float)xPoints[i], (float)yPoints[i]);
if (close)
gp.closePath ();
Shape sh = gp;
if (fill == false &&
stroke != null &&
!(stroke instanceof BasicStroke))
{
sh = stroke.createStrokedShape (gp);
fill = true;
}
if (fill)
fill (sh);
else
draw (sh);
}
public void drawLine (int x1, int y1, int x2, int y2)
{
int xp[] = new int[2];
int yp[] = new int[2];
xp[0] = x1;
xp[1] = x2;
yp[0] = y1;
yp[1] = y2;
doPolygon (xp, yp, 2, false, false);
}
public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints)
{
doPolygon (xPoints, yPoints, nPoints, true, true);
}
public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
{
doPolygon (xPoints, yPoints, nPoints, true, false);
}
public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints)
{
doPolygon (xPoints, yPoints, nPoints, false, false);
}
private boolean drawRaster (ColorModel cm, Raster r)
{
if (r == null)
return false;
SampleModel sm = r.getSampleModel ();
DataBuffer db = r.getDataBuffer ();
if (db == null || sm == null)
return false;
if (cm == null)
cm = ColorModel.getRGBdefault ();
int pixels[] = null;
if (sm.getDataType () == DataBuffer.TYPE_INT &&
db instanceof DataBufferInt &&
db.getNumBanks () == 1)
{
// single bank, ARGB-ints buffer in sRGB space
DataBufferInt dbi = (DataBufferInt)db;
pixels = dbi.getData ();
}
else
pixels = r.getPixels (0, 0, r.getWidth (), r.getHeight (), pixels);
ColorSpace cs = cm.getColorSpace ();
if (cs != null &&
cs.getType () != ColorSpace.CS_sRGB)
{
int pixels2[] = new int[pixels.length];
for (int i = 0; i < pixels2.length; i++)
pixels2[i] = cm.getRGB (pixels[i]);
pixels = pixels2;
}
cairoSave ();
cairoTranslate (x, y);
drawPixels (pixels, r.getWidth (), r.getHeight (), r.getWidth ());
cairoRestore ();
return true;
}
public boolean drawImage (Image img, int x, int y,
ImageObserver observer)
{
if (img instanceof GtkOffScreenImage &&
img.getGraphics () instanceof GdkGraphics2D &&
(transform == null || transform.isIdentity ()))
{
// we are being asked to flush a double buffer from Gdk
GdkGraphics2D g2 = (GdkGraphics2D) img.getGraphics ();
gdkDrawDrawable (g2, x, y);
return true;
}
else
{
if (img instanceof BufferedImage)
{
// draw an image which has actually been loaded into memory fully
BufferedImage b = (BufferedImage) img;
return drawRaster (b.getColorModel (), b.getData ());
}
else
{
// begin progressive loading in a separate thread
new PainterThread (this, img);
return false;
}
}
}
////////////////////////////////////////
////// Supporting Private Classes //////
////////////////////////////////////////
private class PainterThread implements Runnable, ImageConsumer
{
// this is a helper which is spun off when someone tries to do
// Graphics2D.drawImage on an image we cannot determine to be either
// one of our own offscreen images or a BufferedImage; that is, when
// someone wants to draw an image which is possibly still loading over
// a network or something. you run it in a separate thread and it
// writes through to the underlying Graphics2D as pixels becomg
// available.
GdkGraphics2D gr;
Image image;
ColorModel defaultModel;
public PainterThread (GdkGraphics2D g, Image im)
{
image = im;
this.gr = (GdkGraphics2D) g.create ();
new Thread (this).start ();
}
public void imageComplete (int status)
{
}
public void setColorModel (ColorModel model)
{
defaultModel = model;
}
public void setDimensions (int width, int height)
{
}
public void setHints (int hintflags)
{
}
public void setPixels (int x, int y, int w, int h, ColorModel model,
byte[] pixels, int off, int scansize)
{
}
public void setPixels (int x, int y, int w, int h, ColorModel model,
int[] pixels, int off, int scansize)
{
gr.cairoSave ();
gr.cairoTranslate (x, y);
if (model == null)
model = defaultModel;
int pixels2[];
if (model != null)
{
pixels2 = new int[pixels.length];
for (int yy = 0; yy < h; yy++)
for (int xx = 0; xx < w; xx++)
{
int i = yy * scansize + xx;
pixels2[i] = model.getRGB (pixels[i]);
}
}
else
pixels2 = pixels;
gr.drawPixels (pixels2, w, h, scansize);
gr.cairoRestore ();
}
public void setProperties (java.util.Hashtable props)
{
}
public void run ()
{
image.getSource ().startProduction (this);
gr.dispose ();
}
}
private class BitwiseXorComposite implements Composite
{
// this is a special class which does a bitwise XOR composite, for
// backwards compatibility sake. it does *not* implement the
// porter-duff XOR operator. the porter-duff XOR is unrelated to
// bitwise XOR; it just happens to have a similar name but it
// represents a desire to composite the exclusive or of overlapping
// subpixel regions. bitwise XOR is for drawing "highlights" such as
// cursors (in a cheap oldskool bitblit fashion) by inverting colors
// temporarily and then inverting them back.
Color xorColor;
class BitwiseXorCompositeContext implements CompositeContext
{
ColorModel srcColorModel;
ColorModel dstColorModel;
public BitwiseXorCompositeContext (ColorModel s,
ColorModel d)
{
srcColorModel = s;
dstColorModel = d;
}
public void dispose ()
{
}
public void compose (Raster src,
Raster dstIn,
WritableRaster dstOut)
{
Rectangle srcRect = src.getBounds ();
Rectangle dstInRect = dstIn.getBounds ();
Rectangle dstOutRect = dstOut.getBounds ();
int xp = xorColor.getRGB ();
int x = 0, y = 0;
int w = Math.min (Math.min (srcRect.width, dstOutRect.width), dstInRect.width);
int h = Math.min (Math.min (srcRect.height, dstOutRect.height), dstInRect.height);
Object srcPix = null, dstPix = null;
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
{
srcPix = src.getDataElements (x + srcRect.x, y + srcRect.y, srcPix);
dstPix = dstIn.getDataElements (x + dstInRect.x, y + dstInRect.y, dstPix);
int sp = srcColorModel.getRGB (srcPix);
int dp = dstColorModel.getRGB (dstPix);
int rp = sp ^ xp ^ dp;
dstOut.setDataElements (x + dstOutRect.x, y + dstOutRect.y,
dstColorModel.getDataElements (rp, null));
}
}
}
public BitwiseXorComposite (Color c)
{
xorColor = c;
}
public CompositeContext createContext (ColorModel srcColorModel,
ColorModel dstColorModel,
RenderingHints hints)
{
return new BitwiseXorCompositeContext (srcColorModel, dstColorModel);
}
}
///////////////////////////////////////////////
////// Unimplemented Stubs and Overloads //////
///////////////////////////////////////////////
public boolean drawImage(Image image,
AffineTransform xform,
ImageObserver obs)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawImage(BufferedImage image,
BufferedImageOp op,
int x,
int y)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawRenderedImage(RenderedImage image,
AffineTransform xform)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawRenderableImage(RenderableImage image,
AffineTransform xform)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawString(String text, float x, float y)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawString(AttributedCharacterIterator iterator,
float x, float y)
{
throw new java.lang.UnsupportedOperationException ();
}
public boolean hit(Rectangle rect, Shape text,
boolean onStroke)
{
throw new java.lang.UnsupportedOperationException ();
}
public GraphicsConfiguration getDeviceConfiguration()
{
throw new java.lang.UnsupportedOperationException ();
}
public void setComposite(Composite comp)
{
throw new java.lang.UnsupportedOperationException ();
}
public void setRenderingHint(RenderingHints.Key hintKey,
Object hintValue)
{
throw new java.lang.UnsupportedOperationException ();
}
public Object getRenderingHint(RenderingHints.Key hintKey)
{
throw new java.lang.UnsupportedOperationException ();
}
public void setRenderingHints(Map hints)
{
throw new java.lang.UnsupportedOperationException ();
}
public void addRenderingHints(Map hints)
{
throw new java.lang.UnsupportedOperationException ();
}
public RenderingHints getRenderingHints()
{
throw new java.lang.UnsupportedOperationException ();
}
public void shear(double shearX, double shearY)
{
throw new java.lang.UnsupportedOperationException ();
}
public Composite getComposite()
{
throw new java.lang.UnsupportedOperationException ();
}
public FontRenderContext getFontRenderContext ()
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawGlyphVector (GlyphVector g, float x, float y)
{
throw new java.lang.UnsupportedOperationException ();
}
public void copyArea (int x, int y, int width, int height, int dx, int dy)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawArc (int x, int y, int width, int height,
int startAngle, int arcAngle)
{
throw new java.lang.UnsupportedOperationException ();
}
public boolean drawImage (Image img, int x, int y, Color bgcolor,
ImageObserver observer)
{
throw new java.lang.UnsupportedOperationException ();
}
public boolean drawImage (Image img, int x, int y, int width, int height,
Color bgcolor, ImageObserver observer)
{
throw new java.lang.UnsupportedOperationException ();
}
public boolean drawImage (Image img, int x, int y, int width, int height,
ImageObserver observer)
{
throw new java.lang.UnsupportedOperationException ();
}
public boolean drawImage (Image img, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2,
Color bgcolor, ImageObserver observer)
{
throw new java.lang.UnsupportedOperationException ();
}
public boolean drawImage (Image img, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawOval(int x, int y, int width, int height)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawString (String str, int x, int y)
{
throw new java.lang.UnsupportedOperationException ();
}
public void drawString (AttributedCharacterIterator ci, int x, int y)
{
throw new java.lang.UnsupportedOperationException ();
}
public void fillArc (int x, int y, int width, int height,
int startAngle, int arcAngle)
{
cairoNewPath ();
walkPath (new Arc2D.Double((double)x, (double)y,
(double)width, (double)height,
(double)startAngle, (double)arcAngle,
Arc2D.PIE).getPathIterator (null));
cairoClosePath ();
cairoFill ();
}
public void fillOval(int x, int y, int width, int height)
{
throw new java.lang.UnsupportedOperationException ();
}
public void fillRoundRect (int x, int y, int width, int height,
int arcWidth, int arcHeight)
{
throw new java.lang.UnsupportedOperationException ();
}
public Font getFont ()
{
throw new java.lang.UnsupportedOperationException ();
}
public FontMetrics getFontMetrics ()
{
throw new java.lang.UnsupportedOperationException ();
}
public FontMetrics getFontMetrics (Font f)
{
throw new java.lang.UnsupportedOperationException ();
}
public void setFont (Font f)
{
if (f instanceof GdkFont)
font = (GdkFont) f;
else
font = new GdkFont (f.getAttributes ());
}
public String toString()
{
throw new java.lang.UnsupportedOperationException ();
}
}
libjava/gnu/java/awt/peer/gtk/GdkPixbufDecoder.java 0 → 100644
/* GdkPixbufDecoder.java -- Image data decoding object
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.awt.peer.gtk;
import java.awt.image.*;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Vector;
import java.util.Hashtable;
import gnu.classpath.Configuration;
public class GdkPixbufDecoder extends gnu.java.awt.image.ImageDecoder
{
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("gtkpeer");
}
initStaticState ();
}
native static void initStaticState ();
private final int native_state = GtkGenericPeer.getUniqueInteger ();
// the current set of ImageConsumers for this decoder
Vector curr;
// interface to GdkPixbuf
native void initState ();
native void pumpBytes (byte bytes[], int len);
native void finish ();
// gdk-pixbuf provids data in RGBA format
static final ColorModel cm = new DirectColorModel (32, 0xff000000,
0x00ff0000,
0x0000ff00,
0x000000ff);
public GdkPixbufDecoder (String filename)
{
super (filename);
initState ();
}
public GdkPixbufDecoder (URL url)
{
super (url);
initState ();
}
// called back by native side
void areaPrepared (int width, int height)
{
if (curr == null)
return;
for (int i = 0; i < curr.size (); i++)
{
ImageConsumer ic = (ImageConsumer) curr.elementAt (i);
ic.setDimensions (width, height);
ic.setColorModel (cm);
ic.setHints (ImageConsumer.RANDOMPIXELORDER);
}
}
// called back by native side
void areaUpdated (int x, int y, int width, int height,
int pixels[], int scansize)
{
if (curr == null)
return;
for (int i = 0; i < curr.size (); i++)
{
ImageConsumer ic = (ImageConsumer) curr.elementAt (i);
ic.setPixels (x, y, width, height, cm, pixels, 0, scansize);
}
}
// called from an async image loader of one sort or another, this method
// repeatedly reads bytes from the input stream and passes them through a
// GdkPixbufLoader using the native method pumpBytes. pumpBytes in turn
// decodes the image data and calls back areaPrepared and areaUpdated on
// this object, feeding back decoded pixel blocks, which we pass to each
// of the ImageConsumers in the provided Vector.
void produce (Vector v, FileInputStream is) throws IOException
{
curr = v;
byte bytes[] = new byte[4096];
int len = 0;
while ((len = is.read (bytes)) != -1)
pumpBytes (bytes, len);
for (int i = 0; i < curr.size (); i++)
{
ImageConsumer ic = (ImageConsumer) curr.elementAt (i);
ic.imageComplete (ImageConsumer.STATICIMAGEDONE);
}
curr = null;
}
// remaining helper class and static method is a convenience for the Gtk
// peers, for loading a BufferedImage in off a disk file. one would think
// this ought to be fairly straightforward, but it does not appear
// anywhere else I can find.
private class BufferedImageBuilder implements ImageConsumer
{
BufferedImage bufferedImage;
ColorModel defaultModel;
public BufferedImage getBufferedImage()
{
return bufferedImage;
}
public void setDimensions(int width, int height)
{
bufferedImage = new BufferedImage (width, height, BufferedImage.TYPE_INT_ARGB);
}
public void setProperties(Hashtable props) {}
public void setColorModel(ColorModel model)
{
defaultModel = model;
}
public void setHints(int flags) {}
public void setPixels(int x, int y, int w, int h,
ColorModel model, byte[] pixels,
int offset, int scansize)
{
}
public void setPixels(int x, int y, int w, int h,
ColorModel model, int[] pixels,
int offset, int scansize)
{
if (bufferedImage != null)
{
if (model == null)
model = defaultModel;
int pixels2[];
if (model != null)
{
pixels2 = new int[pixels.length];
for (int yy = 0; yy < h; yy++)
for (int xx = 0; xx < w; xx++)
{
int i = yy * scansize + xx;
pixels2[i] = model.getRGB (pixels[i]);
}
}
else
pixels2 = pixels;
bufferedImage.setRGB (x, y, w, h, pixels2, offset, scansize);
}
}
public void imageComplete(int status) {}
}
public static BufferedImage createBufferedImage (String filename)
{
BufferedImageBuilder bb = new BufferedImageBuilder ();
GdkPixbufDecoder dec = new GdkPixbufDecoder (filename);
dec.startProduction (bb);
return bb.getBufferedImage ();
}
}
libjava/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics2D.c 0 → 100644
/* gnu_java_awt_peer_gtk_GdkGraphics2d.c
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
#include "gtkpeer.h"
#include "gnu_java_awt_peer_gtk_GdkGraphics2D.h"
#include <gdk/gdktypes.h>
#include <gdk/gdkprivate.h>
#include <gdk/gdkx.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gdk-pixbuf/gdk-pixdata.h>
#include <cairo.h>
#include <stdio.h>
#include <stdlib.h>
struct state_table *native_graphics2d_state_table;
#define NSA_G2D_INIT(env, clazz) \
native_graphics2d_state_table = init_state_table (env, clazz)
#define NSA_GET_G2D_PTR(env, obj) \
get_state (env, obj, native_graphics2d_state_table)
#define NSA_SET_G2D_PTR(env, obj, ptr) \
set_state (env, obj, native_graphics2d_state_table, (void *)ptr)
#define NSA_DEL_G2D_PTR(env, obj) \
remove_state_slot (env, obj, native_graphics2d_state_table)
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initStaticState
(JNIEnv *env, jclass clazz)
{
NSA_G2D_INIT (env, clazz);
}
/* these public final constants are part of the java2d public API, so we
write them explicitly here to save fetching them from the constant pool
all the time. */
#ifndef min
#define min(x,y) ((x) < (y) ? (x) : (y))
#endif
enum java_awt_alpha_composite_rule
{
java_awt_alpha_composite_CLEAR = 1,
java_awt_alpha_composite_SRC = 2,
java_awt_alpha_composite_SRC_OVER = 3,
java_awt_alpha_composite_DST_OVER = 4,
java_awt_alpha_composite_SRC_IN = 5,
java_awt_alpha_composite_DST_IN = 6,
java_awt_alpha_composite_SRC_OUT = 7,
java_awt_alpha_composite_DST_OUT = 8,
java_awt_alpha_composite_DST = 9,
java_awt_alpha_composite_SRC_ATOP = 10,
java_awt_alpha_composite_DST_ATOP = 11,
java_awt_alpha_composite_XOR = 12
};
enum java_awt_basic_stroke_join_rule
{
java_awt_basic_stroke_JOIN_MITER = 0,
java_awt_basic_stroke_JOIN_ROUND = 1,
java_awt_basic_stroke_JOIN_BEVEL = 2
};
enum java_awt_basic_stroke_cap_rule
{
java_awt_basic_stroke_CAP_BUTT = 0,
java_awt_basic_stroke_CAP_ROUND = 1,
java_awt_basic_stroke_CAP_SQUARE = 2
};
enum java_awt_geom_path_iterator_winding_rule
{
java_awt_geom_path_iterator_WIND_EVEN_ODD = 0,
java_awt_geom_path_iterator_WIND_NON_ZERO = 1
};
static void
grab_current_drawable (GtkWidget *widget, GdkDrawable **draw, GdkWindow **win)
{
g_assert (widget != NULL);
g_assert (draw != NULL);
g_assert (win != NULL);
if (GTK_IS_WINDOW (widget))
{
*win = find_gtk_layout (widget)->bin_window;
}
else if (GTK_IS_LAYOUT (widget))
{
*win = GTK_LAYOUT (widget)->bin_window;
}
else
{
*win = widget->window;
}
*draw = *win;
gdk_window_get_internal_paint_info (*win, draw, 0, 0);
g_object_ref (*draw);
}
static int
x_server_has_render_extension (void)
{
int ev = 0, err = 0;
return (int) XRenderQueryExtension (GDK_DISPLAY (), &ev, &err);
}
static void
init_graphics2d_as_pixbuf (struct graphics2d *gr)
{
gint width, height;
gint bits_per_sample = 8;
gint total_channels = 4;
gboolean has_alpha = TRUE;
g_assert (gr != NULL);
g_assert (gr->drawable != NULL);
if (gr->debug) printf ("initializing graphics2d as pixbuf\n");
gdk_drawable_get_size (gr->drawable, &width, &height);
gr->drawbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
has_alpha, bits_per_sample,
width, height);
g_assert (gr->drawbuf != NULL);
g_assert (gdk_pixbuf_get_bits_per_sample (gr->drawbuf) == bits_per_sample);
g_assert (gdk_pixbuf_get_n_channels (gr->drawbuf) == total_channels);
gr->surface = cairo_surface_create_for_image (gdk_pixbuf_get_pixels (gr->drawbuf),
CAIRO_FORMAT_ARGB32,
gdk_pixbuf_get_width (gr->drawbuf),
gdk_pixbuf_get_height (gr->drawbuf),
gdk_pixbuf_get_rowstride (gr->drawbuf));
g_assert (gr->surface != NULL);
g_assert (gr->cr != NULL);
cairo_set_target_surface (gr->cr, gr->surface);
}
static void
init_graphics2d_as_renderable (struct graphics2d *gr)
{
Drawable draw;
Display * dpy;
Visual * vis;
g_assert (gr != NULL);
g_assert (gr->drawable != NULL);
gr->drawbuf = NULL;
if (gr->debug) printf ("initializing graphics2d as renderable\n");
draw = gdk_x11_drawable_get_xid (gr->drawable);
dpy = gdk_x11_drawable_get_xdisplay (gr->drawable);
g_assert (dpy != NULL);
vis = gdk_x11_visual_get_xvisual (gdk_drawable_get_visual (gr->drawable));
g_assert (vis != NULL);
gr->surface = cairo_surface_create_for_drawable (dpy, draw, vis,
CAIRO_FORMAT_ARGB32,
DefaultColormap (dpy, DefaultScreen (dpy)));
g_assert (gr->surface != NULL);
g_assert (gr->cr != NULL);
cairo_set_target_surface (gr->cr, gr->surface);
}
static void
begin_drawing_operation (struct graphics2d * gr)
{
gdk_threads_enter ();
if (gr->drawbuf)
{
gint drawable_width, drawable_height;
gint pixbuf_width, pixbuf_height;
gint width, height;
gdk_drawable_get_size (gr->drawable, &drawable_width, &drawable_height);
pixbuf_width = gdk_pixbuf_get_width (gr->drawbuf);
pixbuf_height = gdk_pixbuf_get_height (gr->drawbuf);
width = min (drawable_width, pixbuf_width);
height = min (drawable_height, pixbuf_height);
gdk_pixbuf_get_from_drawable (gr->drawbuf, /* destination pixbuf */
gr->drawable,
NULL, /* colormap */
0, 0, 0, 0,
width, height);
if (gr->debug) printf ("copied (%d, %d) pixels from GDK drawable to pixbuf\n",
width, height);
}
}
static void
end_drawing_operation (struct graphics2d * gr)
{
if (gr->drawbuf)
{
gint drawable_width, drawable_height;
gint pixbuf_width, pixbuf_height;
gint width, height;
gdk_drawable_get_size (gr->drawable, &drawable_width, &drawable_height);
pixbuf_width = gdk_pixbuf_get_width (gr->drawbuf);
pixbuf_height = gdk_pixbuf_get_height (gr->drawbuf);
width = min (drawable_width, pixbuf_width);
height = min (drawable_height, pixbuf_height);
gdk_draw_pixbuf (gr->drawable, NULL, gr->drawbuf,
0, 0, 0, 0,
width, height,
GDK_RGB_DITHER_NORMAL, 0, 0);
if (gr->debug) printf ("copied (%d, %d) pixels from pixbuf to GDK drawable\n",
width, height);
}
gdk_threads_leave ();
}
static void
update_pattern_transform (struct graphics2d *gr)
{
double a, b, c, d, tx, ty;
cairo_matrix_t *mat = NULL;
g_assert (gr != NULL);
if (gr->pattern == NULL)
return;
return;
/* temporarily disabled: ambiguous behavior */
/* cairo_get_matrix (gr->cr, &a, &b, &c, &d, &tx, &ty); */
mat = cairo_matrix_create ();
g_assert (mat != NULL);
cairo_matrix_set_affine (mat, a, b, c, d, tx, ty);
cairo_surface_set_matrix (gr->pattern, mat);
cairo_matrix_destroy (mat);
}
static void
check_for_debug (struct graphics2d *gr)
{
gr->debug = (gboolean)(getenv("DEBUGJ2D") != NULL);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_copyState
(JNIEnv *env, jobject obj, jobject old)
{
struct graphics2d *g = NULL, *g_old = NULL;
g = (struct graphics2d *) malloc (sizeof (struct graphics2d));
g_assert (g != NULL);
memset (g, 0, sizeof(struct graphics2d));
g_old = (struct graphics2d *) NSA_GET_G2D_PTR (env, old);
g_assert (g_old != NULL);
g->drawable = g_old->drawable;
g->debug = g_old->debug;
gdk_threads_enter ();
g_object_ref (g->drawable);
g->cr = cairo_create();
g_assert (g->cr != NULL);
if (x_server_has_render_extension ())
init_graphics2d_as_renderable (g);
else
init_graphics2d_as_pixbuf (g);
cairo_surface_set_filter (g->surface, CAIRO_FILTER_BILINEAR);
gdk_threads_leave ();
NSA_SET_G2D_PTR (env, obj, g);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initState__II
(JNIEnv *env, jobject obj, jint width, jint height)
{
struct graphics2d *gr;
gdk_threads_enter ();
gr = (struct graphics2d *) malloc (sizeof (struct graphics2d));
g_assert (gr != NULL);
memset (gr, 0, sizeof(struct graphics2d));
check_for_debug (gr);
if (gr->debug) printf ("constructing offscreen drawable of size (%d,%d)\n",
width, height);
gr->drawable = (GdkDrawable *) gdk_pixmap_new (NULL, width, height,
gdk_rgb_get_visual ()->depth);
g_assert (gr->drawable != NULL);
gr->cr = cairo_create();
g_assert (gr->cr != NULL);
if (x_server_has_render_extension ())
init_graphics2d_as_renderable (gr);
else
init_graphics2d_as_pixbuf (gr);
gdk_threads_leave ();
if (gr->debug) printf ("constructed offscreen drawable of size (%d,%d)\n",
width, height);
NSA_SET_G2D_PTR (env, obj, gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable
(JNIEnv *env, jobject self, jobject other, jint x, jint y)
{
struct graphics2d *src = NULL, *dst = NULL;
gint s_height, s_width, d_height, d_width, height, width;
GdkGC *gc;
src = (struct graphics2d *)NSA_GET_G2D_PTR (env, other);
dst = (struct graphics2d *)NSA_GET_G2D_PTR (env, self);
g_assert (src != NULL);
g_assert (dst != NULL);
if (src->debug) printf ("copying from offscreen drawable\n");
gdk_threads_enter ();
gdk_drawable_get_size (src->drawable, &s_width, &s_height);
gdk_drawable_get_size (dst->drawable, &d_width, &d_height);
width = min (s_width, d_width);
height = min (s_width, d_height);
gc = gdk_gc_new (dst->drawable);
g_assert (gc != NULL);
gdk_draw_drawable(dst->drawable, gc, src->drawable,
0, 0, x, y, width, height);
g_object_unref (gc);
if (src->debug) printf ("copied %d x %d pixels from offscreen drawable\n", width, height);
gdk_threads_leave ();
}
static jintArray
current_colors_of_widget (GtkWidget *widget, JNIEnv *env)
{
GdkColor color;
jintArray array;
jint *rgb;
g_assert (widget != NULL);
g_assert (env != NULL);
color = widget->style->fg[GTK_STATE_NORMAL];
array = (*env)->NewIntArray (env, 6);
rgb = (*env)->GetIntArrayElements (env, array, NULL);
rgb[0] = color.red >> 8;
rgb[1] = color.green >> 8;
rgb[2] = color.blue >> 8;
color = widget->style->bg[GTK_STATE_NORMAL];
rgb[3] = color.red >> 8;
rgb[4] = color.green >> 8;
rgb[5] = color.blue >> 8;
(*env)->ReleaseIntArrayElements (env, array, rgb, 0);
return array;
}
JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initState__Lgnu_java_awt_peer_gtk_GtkComponentPeer_2
(JNIEnv *env, jobject obj, jobject peer)
{
struct graphics2d *gr = NULL;
GtkWidget *widget = NULL;
void *ptr = NULL;
jintArray color;
ptr = NSA_GET_PTR (env, peer);
g_assert (ptr != NULL);
gdk_threads_enter ();
gr = (struct graphics2d *) malloc (sizeof (struct graphics2d));
g_assert (gr != NULL);
memset (gr, 0, sizeof(struct graphics2d));
check_for_debug (gr);
gr->cr = cairo_create();
g_assert (gr->cr != NULL);
widget = GTK_WIDGET (ptr);
g_assert (widget != NULL);
grab_current_drawable (widget, &(gr->drawable), &(gr->win));
g_assert (gr->drawable != NULL);
if (x_server_has_render_extension ())
init_graphics2d_as_renderable (gr);
else
init_graphics2d_as_pixbuf (gr);
color = current_colors_of_widget (widget, env);
gdk_threads_leave ();
NSA_SET_G2D_PTR (env, obj, gr);
return color;
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_dispose
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_DEL_G2D_PTR (env, obj);
if (gr == NULL)
return; /* dispose has been called more than once */
gdk_threads_enter ();
if (gr->surface)
cairo_surface_destroy (gr->surface);
cairo_destroy (gr->cr);
if (gr->drawbuf)
g_object_unref (gr->drawbuf);
g_object_unref (gr->drawable);
free (gr);
if (gr->pattern)
cairo_surface_destroy (gr->pattern);
if (gr->pattern_pixels)
free (gr->pattern_pixels);
if (gr->debug) printf ("disposed of graphics2d\n");
gdk_threads_leave ();
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_setGradient
(JNIEnv *env, jobject obj,
jdouble x1, jdouble y1,
jdouble x2, jdouble y2,
jint r1, jint g1, jint b1, jint a1,
jint r2, jint g2, jint b2, jint a2,
jboolean cyclic)
{
struct graphics2d *gr = NULL;
cairo_surface_t *surf = NULL;
cairo_matrix_t *mat = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("setGradient (%f,%f) -> (%f,%f); (%d,%d,%d,%d) -> (%d,%d,%d,%d)\n",
x1, y1,
x2, y2,
r1, g1, b1, a1,
r2, g2, b2, a2);
cairo_save (gr->cr);
if (cyclic)
surf = cairo_surface_create_similar (gr->surface, CAIRO_FORMAT_ARGB32, 3, 2);
else
surf = cairo_surface_create_similar (gr->surface, CAIRO_FORMAT_ARGB32, 2, 2);
g_assert (surf != NULL);
cairo_set_target_surface (gr->cr, surf);
cairo_identity_matrix (gr->cr);
cairo_set_rgb_color (gr->cr, r1 / 255.0, g1 / 255.0, b1 / 255.0);
cairo_set_alpha (gr->cr, a1 / 255.0);
cairo_rectangle (gr->cr, 0, 0, 1, 2);
cairo_fill (gr->cr);
cairo_set_rgb_color (gr->cr, r2 / 255.0, g2 / 255.0, b2 / 255.0);
cairo_set_alpha (gr->cr, a2 / 255.0);
cairo_rectangle (gr->cr, 1, 0, 1, 2);
cairo_fill (gr->cr);
if (cyclic)
{
cairo_set_rgb_color (gr->cr, r1 / 255.0, g1 / 255.0, b1 / 255.0);
cairo_set_alpha (gr->cr, a1 / 255.0);
cairo_rectangle (gr->cr, 2, 0, 1, 2);
cairo_fill (gr->cr);
}
mat = cairo_matrix_create ();
g_assert (mat != NULL);
/*
consider the vector [x2 - x1, y2 - y1] = [p,q]
this is a line in space starting at an 'origin' x1, y1.
it can also be thought of as a "transformed" unit vector in either the
x or y directions. we have just *drawn* our gradient as a unit vector
(well, a 2-3x unit vector) in the x dimension. so what we want to know
is which transformation turns our existing unit vector into [p,q].
which means solving for M in
[p,q] = M[1,0]
[p,q] = |a b| [1,0]
|c d|
[p,q] = [a,c], with b = d = 0.
what does this mean? it means that our gradient is 1-dimensional; as
you move through the x axis of our 2 or 3 pixel gradient from logical
x positions 0 to 1, the transformation of your x coordinate under the
matrix M causes you to accumulate both x and y values in fill
space. the y value of a gradient coordinate is ignored, since the
gradient is one dimensional. which is correct.
unfortunately we want the opposite transformation, it seems, because of
the way cairo is going to use this transformation. I'm a bit confused by
that, but it seems to work right, so we take reciprocals of values and
negate offsets. oh well.
*/
double a = (x2 - x1 == 0.) ? 0. : ((cyclic ? 3.0 : 2.0) / (x2 - x1));
double c = (y2 - y1 == 0.) ? 0. : (1. / (y2 - y1));
double dx = (x1 == 0.) ? 0. : 1. / x1;
double dy = (y1 == 0.) ? 0. : 1. / y1;
cairo_matrix_set_affine (mat,
a, 0.,
c, 0.,
dx, dy);
cairo_surface_set_matrix (surf, mat);
cairo_matrix_destroy (mat);
cairo_surface_set_filter (surf, CAIRO_FILTER_BILINEAR);
/* FIXME: repeating gradients (not to mention hold gradients) don't seem to work. */
/* cairo_surface_set_repeat (surf, cyclic ? 1 : 0); */
if (gr->pattern)
cairo_surface_destroy (gr->pattern);
if (gr->pattern_pixels)
{
free (gr->pattern_pixels);
gr->pattern_pixels = NULL;
}
gr->pattern = surf;
cairo_restore (gr->cr);
cairo_set_pattern (gr->cr, gr->pattern);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_setTexturePixels
(JNIEnv *env, jobject obj, jintArray jarr, jint w, jint h, jint stride)
{
struct graphics2d *gr = NULL;
jint *jpixels = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("setTexturePixels (%d pixels, %dx%d, stride: %d)\n",
(*env)->GetArrayLength (env, jarr), w, h, stride);
if (gr->pattern)
cairo_surface_destroy (gr->pattern);
if (gr->pattern_pixels)
free (gr->pattern_pixels);
gr->pattern = NULL;
gr->pattern_pixels = NULL;
gr->pattern_pixels = (char *) malloc (h * stride * 4);
g_assert (gr->pattern_pixels != NULL);
jpixels = (*env)->GetIntArrayElements (env, jarr, NULL);
g_assert (jpixels != NULL);
memcpy (gr->pattern_pixels, jpixels, h * stride * 4);
(*env)->ReleaseIntArrayElements (env, jarr, jpixels, 0);
gr->pattern = cairo_surface_create_for_image (gr->pattern_pixels,
CAIRO_FORMAT_ARGB32,
w, h, stride * 4);
g_assert (gr->pattern != NULL);
cairo_surface_set_repeat (gr->pattern, 1);
cairo_set_pattern (gr->cr, gr->pattern);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_drawPixels
(JNIEnv *env, jobject obj, jintArray jarr, jint w, jint h, jint stride)
{
struct graphics2d *gr = NULL;
jint *jpixels = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("drawPixels (%d pixels, %dx%d, stride: %d)\n",
(*env)->GetArrayLength (env, jarr), w, h, stride);
jpixels = (*env)->GetIntArrayElements (env, jarr, NULL);
g_assert (jpixels != NULL);
begin_drawing_operation (gr);
{
cairo_surface_t *surf = cairo_surface_create_for_image ((char *)jpixels,
CAIRO_FORMAT_ARGB32,
w, h, stride * 4);
cairo_surface_set_filter (surf, CAIRO_FILTER_BILINEAR);
cairo_show_surface (gr->cr, surf, w, h);
cairo_surface_destroy (surf);
}
end_drawing_operation (gr);
(*env)->ReleaseIntArrayElements (env, jarr, jpixels, 0);
}
/* passthrough methods to cairo */
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSave
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_save\n");
cairo_save (gr->cr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRestore
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_restore\n");
cairo_restore (gr->cr);
update_pattern_transform (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMatrix
(JNIEnv *env, jobject obj,
jdouble m00, jdouble m10,
jdouble m01, jdouble m11,
jdouble m02, jdouble m12)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_matrix\n");
{
cairo_matrix_t * mat = cairo_matrix_create ();
cairo_matrix_set_affine (mat,
m00, m10,
m01, m11,
m02, m12);
cairo_set_matrix (gr->cr, mat);
cairo_matrix_destroy (mat);
}
update_pattern_transform (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetOperator
(JNIEnv *env, jobject obj, jint op)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_operator %d\n", op);
switch ((enum java_awt_alpha_composite_rule) op)
{
case java_awt_alpha_composite_CLEAR:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_CLEAR);
break;
case java_awt_alpha_composite_SRC:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_SRC);
break;
case java_awt_alpha_composite_SRC_OVER:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_OVER);
break;
case java_awt_alpha_composite_DST_OVER:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_OVER_REVERSE);
break;
case java_awt_alpha_composite_SRC_IN:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_IN);
break;
case java_awt_alpha_composite_DST_IN:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_IN_REVERSE);
break;
case java_awt_alpha_composite_SRC_OUT:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_OUT);
break;
case java_awt_alpha_composite_DST_OUT:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_OUT_REVERSE);
break;
case java_awt_alpha_composite_DST:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_DST);
break;
case java_awt_alpha_composite_SRC_ATOP:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_ATOP);
break;
case java_awt_alpha_composite_DST_ATOP:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_ATOP_REVERSE);
break;
case java_awt_alpha_composite_XOR:
cairo_set_operator (gr->cr, CAIRO_OPERATOR_XOR);
break;
}
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetRGBColor
(JNIEnv *env, jobject obj, jdouble r, jdouble g, jdouble b)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
/* this is a very weird fact: GDK Pixbufs and RENDER drawables consider
colors in opposite pixel order. I have no idea why. thus when you
draw to a PixBuf, you must exchange the R and B components of your
color. */
if (gr->debug) printf ("cairo_set_rgb_color (%f, %f, %f)\n", r, g, b);
if (gr->drawbuf)
cairo_set_rgb_color (gr->cr, b, g, r);
else
cairo_set_rgb_color (gr->cr, r, g, b);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetAlpha
(JNIEnv *env, jobject obj, jdouble a)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_alpha %f\n", a);
cairo_set_alpha (gr->cr, a);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetFillRule
(JNIEnv *env, jobject obj, jint rule)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
if (gr->debug) printf ("cairo_set_fill_rule %d\n", rule);
g_assert (gr != NULL);
switch ((enum java_awt_geom_path_iterator_winding_rule) rule)
{
case java_awt_geom_path_iterator_WIND_NON_ZERO:
cairo_set_fill_rule (gr->cr, CAIRO_FILL_RULE_WINDING);
break;
case java_awt_geom_path_iterator_WIND_EVEN_ODD:
cairo_set_fill_rule (gr->cr, CAIRO_FILL_RULE_EVEN_ODD);
break;
}
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineWidth
(JNIEnv *env, jobject obj, jdouble width)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_line_width %f\n", width);
cairo_set_line_width (gr->cr, width);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineCap
(JNIEnv *env, jobject obj, jint cap)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_line_cap %d\n", cap);
switch ((enum java_awt_basic_stroke_cap_rule) cap)
{
case java_awt_basic_stroke_CAP_BUTT:
cairo_set_line_cap (gr->cr, CAIRO_LINE_CAP_BUTT);
break;
case java_awt_basic_stroke_CAP_ROUND:
cairo_set_line_cap (gr->cr, CAIRO_LINE_CAP_ROUND);
break;
case java_awt_basic_stroke_CAP_SQUARE:
cairo_set_line_cap (gr->cr, CAIRO_LINE_CAP_SQUARE);
break;
}
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineJoin
(JNIEnv *env, jobject obj, jint join)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_line_join %d\n", join);
switch ((enum java_awt_basic_stroke_join_rule) join)
{
case java_awt_basic_stroke_JOIN_MITER:
cairo_set_line_join (gr->cr, CAIRO_LINE_JOIN_MITER);
break;
case java_awt_basic_stroke_JOIN_ROUND:
cairo_set_line_join (gr->cr, CAIRO_LINE_JOIN_ROUND);
break;
case java_awt_basic_stroke_JOIN_BEVEL:
cairo_set_line_join (gr->cr, CAIRO_LINE_JOIN_BEVEL);
break;
}
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetDash
(JNIEnv *env, jobject obj, jdoubleArray dashes, jint ndash, jdouble offset)
{
struct graphics2d *gr = NULL;
jdouble *dasharr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_dash\n");
dasharr = (*env)->GetDoubleArrayElements (env, dashes, NULL);
g_assert (dasharr != NULL);
cairo_set_dash (gr->cr, dasharr, ndash, offset);
(*env)->ReleaseDoubleArrayElements (env, dashes, dasharr, 0);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMiterLimit
(JNIEnv *env, jobject obj, jdouble miter)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_miter_limit %f\n", miter);
cairo_set_miter_limit (gr->cr, miter);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoTranslate
(JNIEnv *env, jobject obj, jdouble dx, jdouble dy)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_translate (%f, %f)\n", dx, dy);
cairo_translate (gr->cr, dx, dy);
update_pattern_transform (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoScale
(JNIEnv *env, jobject obj, jdouble sx, jdouble sy)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_scale (%f, %f)\n", sx, sy);
cairo_scale (gr->cr, sx, sy);
update_pattern_transform (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRotate
(JNIEnv *env, jobject obj, jdouble angle)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_rotate %f\n", angle);
cairo_rotate (gr->cr, angle);
update_pattern_transform (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoNewPath
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_new_path\n");
cairo_new_path (gr->cr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoMoveTo
(JNIEnv *env, jobject obj, jdouble x, jdouble y)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_move_to (%f, %f)\n", x, y);
cairo_move_to (gr->cr, x, y);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoLineTo
(JNIEnv *env, jobject obj, jdouble x, jdouble y)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_line_to (%f, %f)\n", x, y);
cairo_line_to (gr->cr, x, y);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoCurveTo
(JNIEnv *env, jobject obj, jdouble x1, jdouble y1, jdouble x2, jdouble y2, jdouble x3, jdouble y3)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_curve_to (%f, %f), (%f, %f), (%f, %f)\n", x1, y1, x2, y2, x3, y3);
cairo_curve_to (gr->cr, x1, y1, x2, y2, x3, y3);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRelMoveTo
(JNIEnv *env, jobject obj, jdouble dx, jdouble dy)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_rel_move_to (%f, %f)\n", dx, dy);
cairo_rel_move_to (gr->cr, dx, dy);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRelLineTo
(JNIEnv *env, jobject obj, jdouble dx, jdouble dy)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_rel_line_to (%f, %f)\n", dx, dy);
cairo_rel_line_to (gr->cr, dx, dy);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRelCurveTo
(JNIEnv *env, jobject obj, jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2, jdouble dx3, jdouble dy3)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_rel_curve_to (%f, %f), (%f, %f), (%f, %f)\n", dx1, dy1, dx2, dy2, dx3, dy3);
cairo_rel_curve_to (gr->cr, dx1, dy1, dx2, dy2, dx3, dy3);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRectangle
(JNIEnv *env, jobject obj, jdouble x, jdouble y, jdouble width, jdouble height)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_rectangle (%f, %f) (%f, %f)\n", x, y, width, height);
cairo_rectangle (gr->cr, x, y, width, height);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoClosePath
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_close_path\n");
cairo_close_path (gr->cr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoStroke
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_stroke\n");
begin_drawing_operation (gr);
cairo_stroke (gr->cr);
end_drawing_operation (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoFill
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_fill\n");
begin_drawing_operation (gr);
cairo_fill (gr->cr);
end_drawing_operation (gr);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoClip
(JNIEnv *env, jobject obj)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_clip\n");
cairo_clip (gr->cr);
}
libjava/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkPixbufDecoder.c 0 → 100644
/* gdkpixbufdecoder.c
Copyright (C) 1999, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gdk-pixbuf/gdk-pixbuf-loader.h>
#include "gtkpeer.h"
#include "gnu_java_awt_peer_gtk_GdkPixbufDecoder.h"
struct state_table *native_pixbufdecoder_state_table;
#define NSA_PB_INIT(env, clazz) \
native_pixbufdecoder_state_table = init_state_table (env, clazz)
#define NSA_GET_PB_PTR(env, obj) \
get_state (env, obj, native_pixbufdecoder_state_table)
#define NSA_SET_PB_PTR(env, obj, ptr) \
set_state (env, obj, native_pixbufdecoder_state_table, (void *)ptr)
#define NSA_DEL_PB_PTR(env, obj) \
remove_state_slot (env, obj, native_pixbufdecoder_state_table)
jmethodID areaPreparedID;
jmethodID areaUpdatedID;
static void
area_prepared (GdkPixbufLoader *loader,
jobject *decoder)
{
jint width, height;
GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf == NULL)
return;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf),
gdk_threads_leave ();
g_assert (decoder != NULL);
(*gdk_env)->CallVoidMethod (gdk_env,
*decoder,
areaPreparedID,
width, height);
gdk_threads_enter ();
}
static void
area_updated (GdkPixbufLoader *loader,
gint x, gint y,
gint width, gint height,
jobject *decoder)
{
jint stride_bytes, stride_pixels, n_channels, n_pixels;
int i, px;
jintArray jpixels;
jint *java_pixels;
guchar *gdk_pixels;
GdkPixbuf *pixbuf_no_alpha = NULL;
GdkPixbuf *pixbuf = NULL;
pixbuf_no_alpha = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf_no_alpha == NULL)
return;
pixbuf = gdk_pixbuf_add_alpha(pixbuf_no_alpha, FALSE, 0, 0, 0);
g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
stride_bytes = gdk_pixbuf_get_rowstride (pixbuf);
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
stride_pixels = stride_bytes / n_channels;
n_pixels = height * stride_pixels;
gdk_pixels = gdk_pixbuf_get_pixels (pixbuf);
jpixels = (*gdk_env)->NewIntArray (gdk_env, n_pixels);
java_pixels = (*gdk_env)->GetIntArrayElements (gdk_env, jpixels, NULL);
memcpy (java_pixels,
gdk_pixels + (y * stride_bytes),
(height * stride_bytes));
for (i = 0; i < n_pixels; ++i)
{
px = java_pixels[i];
/* move alpha around (GdkPixbufLoader results are AGBR not GBRA, in
the lsb sense) */
/* px = ((px >> 24) & 0xff) | ((px << 8) & 0xffffff00); */
/* it appears to require a full byte swap, now, not just a shift to
the A channel. why did this change? don't know. */
px = ((px >> 8) & 0x00ff00ff) | ((px << 8) & 0xff00ff00);
px = ((px >> 16) & 0x0000ffff) | ((px << 16) & 0xffff0000);
java_pixels[i] = px;
}
g_object_unref (pixbuf);
gdk_threads_leave ();
(*gdk_env)->ReleaseIntArrayElements (gdk_env, jpixels, java_pixels, 0);
(*gdk_env)->CallVoidMethod (gdk_env,
*decoder,
areaUpdatedID,
(jint) x, (jint) y,
(jint) width, (jint) height,
jpixels,
stride_pixels);
gdk_threads_enter ();
}
static void
closed (GdkPixbufLoader *loader, jobject *decoder)
{
gdk_threads_leave ();
(*gdk_env)->DeleteGlobalRef (gdk_env, *decoder);
free (decoder);
gdk_threads_enter ();
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_initState
(JNIEnv *env, jobject obj)
{
GdkPixbufLoader *loader = NULL;
jobject *decoder = NULL;
decoder = (jobject *) malloc (sizeof (jobject));
g_assert (decoder != NULL);
*decoder = (*env)->NewGlobalRef (env, obj);
gdk_threads_enter ();
loader = gdk_pixbuf_loader_new ();
g_assert (loader != NULL);
g_signal_connect (loader, "area-prepared", G_CALLBACK (area_prepared), decoder);
g_signal_connect (loader, "area-updated", G_CALLBACK (area_updated), decoder);
g_signal_connect (loader, "closed", G_CALLBACK (closed), decoder);
gdk_threads_leave ();
NSA_SET_PB_PTR (env, obj, loader);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_initStaticState
(JNIEnv *env, jclass clazz)
{
areaPreparedID = (*env)->GetMethodID (env, clazz,
"areaPrepared",
"(II)V");
areaUpdatedID = (*env)->GetMethodID (env, clazz,
"areaUpdated",
"(IIII[II)V");
NSA_PB_INIT (env, clazz);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_finish
(JNIEnv *env, jobject obj)
{
GdkPixbufLoader *loader = NULL;
loader = (GdkPixbufLoader *)NSA_DEL_PB_PTR (env, obj);
if (loader == NULL)
return;
gdk_threads_enter ();
gdk_pixbuf_loader_close (loader, NULL);
g_object_unref (loader);
gdk_threads_leave ();
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_pumpBytes
(JNIEnv *env, jobject obj, jbyteArray jarr, jint len)
{
GdkPixbufLoader *loader = NULL;
jbyte *bytes = NULL;
if (len < 1)
return;
bytes = (*gdk_env)->GetByteArrayElements (gdk_env, jarr, NULL);
g_assert (bytes != NULL);
loader = (GdkPixbufLoader *)NSA_GET_PB_PTR (env, obj);
g_assert (loader != NULL);
gdk_threads_enter ();
gdk_pixbuf_loader_write (loader, bytes, len, NULL);
gdk_threads_leave ();
(*gdk_env)->ReleaseByteArrayElements (gdk_env, jarr, bytes, 0);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment