+2006-06-13 Thomas Fitzsimmons <fitzsim@redhat.com>
+
+ * configure: Regenerate.
+ * Makefile.in: Regenerate.
+ * configure.ac (--enable-plugin): New option.
+ (ac_configure_args): Add --enable-tool-wrappers.
+ (ac_configure_args): Add --disable-plugin unless --enable-plugin
+ was specified.
+ * gcj/Makefile.in: Regenerate.
+ * sources.am (gnu_java_net_source_files): Add
+ classpath/gnu/java/net/IndexListParser.java.
+ (property_files): Remove
+ classpath/resource/gnu/classpath/tools/jarsigner/MessageBundle.properties,
+ classpath/resource/gnu/classpath/tools/keytool/MessageBundle.properties.
+ Add
+ classpath/resource/gnu/classpath/tools/appletviewer/MessagesBundle.properties,
+ classpath/resource/gnu/classpath/tools/appletviewer/MessagesBundle_de.properties,
+ classpath/resource/gnu/classpath/tools/getopt/Messages.properties,
+ classpath/resource/gnu/classpath/tools/jar/messages.properties,
+ classpath/resource/gnu/classpath/tools/jarsigner/messages.properties,
+ classpath/resource/gnu/classpath/tools/keytool/messages.properties,
+ classpath/resource/gnu/classpath/tools/native2ascii/messages.properties,
+ classpath/resource/gnu/classpath/tools/serialver/messages.properties.
+ * classpath/Makefile.in: Regenerate.
+ * classpath/native/jni/gtk-peer/cairographics2d.h,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_CairoGraphics2D.c,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkPixbufDecoder.c,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_FreetypeGlyphVector.c,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_ComponentGraphics.c,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkVolatileImage.c,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_CairoSurface.c,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkTextLayout.c:
+ Merge from GNU Classpath.
+ * classpath/native/Makefile.in: Regenerate.
+ * classpath/native/jawt/Makefile.in: Regenerate.
+ * classpath/native/jawt/Makefile.am: Install libjawt.so in GCJ's
+ versioned library directory.
+ * classpath/native/Makefile.am: Add plugin directory if
+ --enable-plugin was specified.
+ * classpath/native/plugin/Makefile.in: Regenerate. *
+ classpath/native/plugin/Makefile.am: Install libgcjwebplugin.so in
+ GCJ's versioned library directory.
+ * classpath/resource/gnu/classpath/tools/native2ascii/messages.properties:
+ New file.
+ * classpath/resource/gnu/classpath/tools/getopt/Messages.properties:
+ Likewise.
+ * classpath/resource/gnu/classpath/tools/jarsigner/messages.properties:
+ Likewise.
+ * classpath/resource/gnu/classpath/tools/jarsigner/MessageBundle.properties:
+ Remove file.
+ * classpath/resource/gnu/classpath/tools/keytool/messages.properties:
+ New file.
+ * classpath/resource/gnu/classpath/tools/keytool/MessageBundle.properties:
+ Remove file.
+ * classpath/resource/gnu/classpath/tools/appletviewer/MessagesBundle_de.properties:
+ New file.
+ * classpath/resource/gnu/classpath/tools/appletviewer/MessagesBundle.properties:
+ Likewise.
+ * classpath/resource/gnu/classpath/tools/jar/messages.properties:
+ Likewise.
+ * classpath/resource/gnu/classpath/tools/serialver/messages.properties:
+ Likewise.
+ * classpath/gnu/java/net/IndexListParser.java:
+ Likewise.
+ * classpath/gnu/java/awt/peer/gtk/VolatileImageGraphics.java,
+ classpath/gnu/java/awt/peer/gtk/CairoGraphics2D.java,
+ classpath/gnu/java/awt/peer/gtk/CairoSurface.java,
+ classpath/gnu/java/awt/peer/gtk/GdkFontPeer.java,
+ classpath/gnu/java/awt/peer/gtk/GdkPixbufDecoder.java,
+ classpath/gnu/java/awt/peer/gtk/FreetypeGlyphVector.java,
+ classpath/gnu/java/awt/peer/gtk/GdkTextLayout.java,
+ classpath/gnu/java/awt/peer/gtk/ComponentGraphics.java,
+ classpath/gnu/java/awt/peer/gtk/CairoSurfaceGraphics.java,
+ classpath/gnu/java/awt/peer/gtk/GtkVolatileImage.java,
+ classpath/gnu/java/awt/font/opentype/truetype/VirtualMachine.java,
+ classpath/gnu/java/awt/java2d/PolyEdge.java,
+ classpath/gnu/java/awt/java2d/AbstractGraphics2D.java: Merge from
+ GNU Classpath.
+ * classpath/tools/toolwrapper.c: Replace tools.zip reference with
+ libgcj-tools-4.2.0.jar.
+ * classpath/tools/Makefile.in: Regenerate.
+ * classpath/tools/Makefile.am: Rename tools.zip to
+ libgcj-tools-4.2.0.jar. Install libgcj-tools-4.2.0.jar in
+ $(datadir)/java.
+ * classpath/javax/swing/JTabbedPane.java,
+ classpath/javax/swing/text/DefaultStyledDocument.java,
+ classpath/javax/swing/text/html/HTMLDocument.java,
+ classpath/javax/swing/text/GapContent.java,
+ classpath/javax/swing/JComponent.java,
+ classpath/javax/swing/RepaintManager.java,
+ classpath/javax/swing/plaf/basic/BasicComboBoxRenderer.java,
+ classpath/javax/swing/plaf/basic/BasicScrollBarUI.java,
+ classpath/javax/swing/plaf/basic/BasicTabbedPaneUI.java,
+ classpath/javax/swing/plaf/basic/BasicScrollPaneUI.java,
+ classpath/javax/swing/plaf/basic/BasicLookAndFeel.java,
+ classpath/javax/swing/plaf/metal/MetalButtonUI.java,
+ classpath/java/text/Bidi.java,
+ classpath/java/awt/image/BufferedImage.java,
+ classpath/java/awt/datatransfer/DataFlavor.java,
+ classpath/java/awt/geom/AffineTransform.java,
+ classpath/java/awt/dnd/DropTargetDropEvent.java,
+ classpath/java/awt/dnd/DropTargetContext.java,
+ classpath/java/awt/font/TextLayout.java,
+ classpath/include/gnu_java_awt_peer_gtk_ComponentGraphics.h,
+ classpath/include/gnu_java_awt_peer_gtk_CairoGraphics2D.h,
+ classpath/include/gnu_java_awt_peer_gtk_FreetypeGlyphVector.h,
+ classpath/include/gnu_java_awt_peer_gtk_GdkTextLayout.h,
+ classpath/include/gnu_java_awt_peer_gtk_GtkVolatileImage.h,
+ classpath/include/gnu_java_awt_peer_gtk_CairoSurface.h: Merge from
+ GNU Classpath.
+ * classpath/include/gnu_java_awt_peer_gtk_GdkGraphics.h,
+ classpath/include/gnu_java_awt_peer_gtk_GdkGraphics2D.h,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics2D.c,
+ classpath/native/jni/gtk-peer/gtkcairopeer.h,
+ classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics.c:
+ Remove files.
+ * classpath/Makefile.am (SUBDIRS, DIST_SUBDIRS): Include tools
+ directory.
+ * include/Makefile.in: Regenerate.
+ * testsuite/Makefile.in: Regenerate.
+
2006-06-13 John David Anglin <dave.anglin@nrc-cnrc.gc.ca>
* configure.host (hppa*-*): Set 'enable_hash_synchronization_default'
BACKTRACESPEC = @BACKTRACESPEC@
BASH_JAR_FALSE = @BASH_JAR_FALSE@
BASH_JAR_TRUE = @BASH_JAR_TRUE@
-CAIRO_CFLAGS = @CAIRO_CFLAGS@
-CAIRO_LIBS = @CAIRO_LIBS@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
GCTESTSPEC = @GCTESTSPEC@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
-GTK_CAIRO_FALSE = @GTK_CAIRO_FALSE@
-GTK_CAIRO_TRUE = @GTK_CAIRO_TRUE@
GTK_CFLAGS = @GTK_CFLAGS@
GTK_LIBS = @GTK_LIBS@
HASH_SYNC_SPEC = @HASH_SYNC_SPEC@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
-PANGOFT2_CFLAGS = @PANGOFT2_CFLAGS@
-PANGOFT2_LIBS = @PANGOFT2_LIBS@
PATH_SEPARATOR = @PATH_SEPARATOR@
PERL = @PERL@
PKG_CONFIG = @PKG_CONFIG@
classpath/gnu/java/net/EmptyX509TrustManager.java \
classpath/gnu/java/net/GetLocalHostAction.java \
classpath/gnu/java/net/HeaderFieldHelper.java \
+classpath/gnu/java/net/IndexListParser.java \
classpath/gnu/java/net/LineInputStream.java \
gnu/java/net/PlainDatagramSocketImpl.java \
gnu/java/net/PlainSocketImpl.java \
org-xml.lo
property_files = \
- classpath/resource/gnu/classpath/tools/jarsigner/MessageBundle.properties \
- classpath/resource/gnu/classpath/tools/keytool/MessageBundle.properties \
+ classpath/resource/gnu/classpath/tools/appletviewer/MessagesBundle.properties \
+ classpath/resource/gnu/classpath/tools/appletviewer/MessagesBundle_de.properties \
+ classpath/resource/gnu/classpath/tools/getopt/Messages.properties \
+ classpath/resource/gnu/classpath/tools/jar/messages.properties \
+ classpath/resource/gnu/classpath/tools/jarsigner/messages.properties \
+ classpath/resource/gnu/classpath/tools/keytool/messages.properties \
+ classpath/resource/gnu/classpath/tools/native2ascii/messages.properties \
+ classpath/resource/gnu/classpath/tools/serialver/messages.properties \
classpath/resource/gnu/java/awt/peer/gtk/font.properties \
classpath/resource/gnu/javax/print/PrinterDialog.properties \
classpath/resource/gnu/javax/print/PrinterDialog_de.properties \
## Input file for automake to generate the Makefile.in used by configure
# lib first, to compile .class files before native code, last examples
-## GCJ LOCAL: we remove 'tools' for the time being.
-## We don't build any of them into actual tools yet.
-SUBDIRS = lib doc external include native resource scripts $(EXAMPLESDIR)
-DIST_SUBDIRS = lib doc external include native resource scripts examples
+SUBDIRS = lib doc external include native resource scripts tools $(EXAMPLESDIR)
+DIST_SUBDIRS = lib doc external include native resource scripts tools examples
## GCJ LOCAL: we need an extra -I here.
ACLOCAL_AMFLAGS = -I m4 -I ../.. -I ../../config
vm_classes = @vm_classes@
# lib first, to compile .class files before native code, last examples
-SUBDIRS = lib doc external include native resource scripts $(EXAMPLESDIR)
-DIST_SUBDIRS = lib doc external include native resource scripts examples
+SUBDIRS = lib doc external include native resource scripts tools $(EXAMPLESDIR)
+DIST_SUBDIRS = lib doc external include native resource scripts tools examples
ACLOCAL_AMFLAGS = -I m4 -I ../.. -I ../../config
EXTRA_DIST = HACKING BUGS THANKYOU mauve-classpath LICENSE \
ChangeLog-2003 ChangeLog-2004 ChangeLog-2005 \
stack[sp] = ((e1 != 0) || (stack[sp] != 0)) ? 1 : 0;
break;
+ case 0x5C: // NOT
+ stack[sp] = (stack[sp] != 0) ? 0 : 1;
+ break;
+
case 0x5e: // SDB, Set Delta Base in the graphics state
deltaBase = stack[sp--];
break;
/* 50 */ "LT", "LTEQ", "GT", "GTEQ",
/* 54 */ "EQ", "NEQ", "INST_56", "INST_57",
/* 58 */ "IF", "EIF", "AND", "OR",
- /* 5c */ "INST_5C", "INST_5D", "SDB", "SDS",
+ /* 5c */ "NOT", "INST_5D", "SDB", "SDS",
/* 60 */ "ADD", "SUB", "DIV", "MUL",
/* 64 */ "ABS", "NEG", "FLOOR", "CEILING",
/* 68 */ "ROUND[0]", "ROUND[1]", "ROUND[2]", "ROUND[3]",
{
AffineTransform t = new AffineTransform();
t.translate(x, y);
- double scaleX = (double) image.getWidth(observer) / (double) width;
- double scaleY = (double) image.getHeight(observer) / (double) height;
+ double scaleX = (double) width / (double) image.getWidth(observer);
+ double scaleY = (double) height / (double) image.getHeight(observer);
t.scale(scaleX, scaleY);
return drawImage(image, t, observer);
}
antialias = (v == RenderingHints.VALUE_ANTIALIAS_ON);
}
- double offs = 0.5;
- if (antialias)
- offs = offs / AA_SAMPLING;
-
Rectangle2D userBounds = s.getBounds2D();
Rectangle2D deviceBounds = new Rectangle2D.Double();
- ArrayList segs = getSegments(s, transform, deviceBounds, false, offs);
+ ArrayList segs = getSegments(s, transform, deviceBounds, false);
Rectangle2D clipBounds = new Rectangle2D.Double();
- ArrayList clipSegs = getSegments(clip, transform, clipBounds, true, offs);
+ ArrayList clipSegs = getSegments(clip, transform, clipBounds, true);
segs.addAll(clipSegs);
Rectangle2D inclClipBounds = new Rectangle2D.Double();
Rectangle2D.union(clipBounds, deviceBounds, inclClipBounds);
// Scan all relevant lines.
int minYInt = (int) Math.ceil(icMinY);
- for (int y = minYInt; y <= maxY; y++)
+
+ Rectangle devClip = getDeviceBounds();
+ int scanlineMax = (int) Math.min(maxY, devClip.getMaxY());
+ for (int y = minYInt; y < scanlineMax; y++)
{
ArrayList bucket = edgeTable[y - minYInt];
// Update all the x intersections in the current activeEdges table
* @return a list of PolyEdge that form the shape in device space
*/
private ArrayList getSegments(Shape s, AffineTransform t,
- Rectangle2D deviceBounds, boolean isClip,
- double offs)
+ Rectangle2D deviceBounds, boolean isClip)
{
// Flatten the path. TODO: Determine the best flattening factor
// wrt to speed and quality.
else if (segType == PathIterator.SEG_CLOSE)
{
// Close the polyline.
- PolyEdge edge = new PolyEdge(segX, segY - offs,
- polyX, polyY - offs, isClip);
+ PolyEdge edge = new PolyEdge(segX, segY,
+ polyX, polyY, isClip);
segs.add(edge);
}
else if (segType == PathIterator.SEG_LINETO)
{
- PolyEdge edge = new PolyEdge(segX, segY - offs,
- seg[0], seg[1] - offs, isClip);
+ PolyEdge edge = new PolyEdge(segX, segY,
+ seg[0], seg[1], isClip);
segs.add(edge);
segX = seg[0];
segY = seg[1];
public String toString()
{
return "Edge: " + x0 + ", " + y0 + ", " + x1 + ", " + y1 + ", slope: "
- + slope + ", xIntersection: " + xIntersection;
+ + slope + ", xIntersection: " + xIntersection
+ + ", isClip: " + isClip;
}
}
package gnu.java.awt.peer.gtk;
-import gnu.classpath.Configuration;
import gnu.java.awt.ClasspathToolkit;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
-import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Toolkit;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
+import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.geom.Arc2D;
import java.awt.geom.Area;
-import java.awt.geom.Line2D;
import java.awt.geom.GeneralPath;
+import java.awt.geom.Line2D;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.PathIterator;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ColorModel;
-import java.awt.image.CropImageFilter;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferInt;
import java.awt.image.DirectColorModel;
-import java.awt.image.FilteredImageSource;
import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
import java.awt.image.ImagingOpException;
import java.awt.image.MultiPixelPackedSampleModel;
import java.awt.image.Raster;
import java.text.AttributedCharacterIterator;
import java.util.HashMap;
import java.util.Map;
-import java.util.Stack;
/**
* This is an abstract implementation of Graphics2D on Cairo.
bg = new Color(g.bg.getRGB());
}
- if (g.clip == null)
- clip = null;
- else
- clip = new Rectangle(g.getClipBounds());
+ clip = g.getClip();
if (g.transform == null)
- transform = new AffineTransform();
+ transform = null;
else
transform = new AffineTransform(g.transform);
setBackground(bg);
setPaint(paint);
setStroke(stroke);
- setTransform(transform);
+ setTransformImpl(transform);
+ setClip(clip);
}
/**
* they have additional native structures.
*/
public void dispose()
- {
- disposeNative();
+ {
+ disposeNative(nativePointer);
nativePointer = 0;
}
/**
* Dispose of allocate native resouces.
*/
- public native void disposeNative();
+ public native void disposeNative(long pointer);
/**
* Draw pixels as an RGBA int matrix
* @param stride - stride of the array width
* @param i2u - affine transform array
*/
- private native void drawPixels(int[] pixels, int w, int h, int stride,
- double[] i2u);
+ private native void drawPixels(long pointer, int[] pixels, int w, int h,
+ int stride, double[] i2u, double alpha);
- private native void setGradient(double x1, double y1, double x2, double y2,
+ private native void setGradient(long pointer, 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);
- private native void setTexturePixels(int[] pixels, int w, int h, int stride);
+ private native void setTexturePixels(long pointer, int[] pixels, int w,
+ int h, int stride);
/**
* Set the current transform matrix
*/
- private native void cairoSetMatrix(double[] m);
+ private native void cairoSetMatrix(long pointer, double[] m);
/**
* Set the compositing operator
*/
- private native void cairoSetOperator(int cairoOperator);
+ private native void cairoSetOperator(long pointer, int cairoOperator);
/**
* Sets the current color in RGBA as a 0.0-1.0 double
*/
- private native void cairoSetRGBAColor(double red, double green,
+ private native void cairoSetRGBAColor(long pointer, double red, double green,
double blue, double alpha);
/**
* Sets the current winding rule in Cairo
*/
- private native void cairoSetFillRule(int cairoFillRule);
+ private native void cairoSetFillRule(long pointer, int cairoFillRule);
/**
* Set the line style, cap, join and miter limit.
* Cap and join parameters are in the BasicStroke enumerations.
*/
- private native void cairoSetLine(double width, int cap, int join, double miterLimit);
+ private native void cairoSetLine(long pointer, double width, int cap,
+ int join, double miterLimit);
/**
* Set the dash style
*/
- private native void cairoSetDash(double[] dashes, int ndash, double offset);
+ private native void cairoSetDash(long pointer, double[] dashes, int ndash,
+ double offset);
/*
* Draws a Glyph Vector
*/
- native void cairoDrawGlyphVector(GdkFontPeer font,
+ native void cairoDrawGlyphVector(long pointer, GdkFontPeer font,
float x, float y, int n,
int[] codes, float[] positions);
- private native void cairoRelCurveTo(double dx1, double dy1, double dx2,
- double dy2, double dx3, double dy3);
+ private native void cairoRelCurveTo(long pointer, double dx1, double dy1,
+ double dx2, double dy2, double dx3,
+ double dy3);
/**
* Appends a rectangle to the current path
*/
- private native void cairoRectangle(double x, double y, double width,
- double height);
+ private native void cairoRectangle(long pointer, double x, double y,
+ double width, double height);
/**
* New current path
*/
- private native void cairoNewPath();
+ private native void cairoNewPath(long pointer);
/**
* Close current path
*/
- private native void cairoClosePath();
+ private native void cairoClosePath(long pointer);
/** moveTo */
- private native void cairoMoveTo(double x, double y);
+ private native void cairoMoveTo(long pointer, double x, double y);
/** relative moveTo */
- private native void cairoRelMoveTo(double dx, double dy);
+ private native void cairoRelMoveTo(long pointer, double dx, double dy);
/** lineTo */
- private native void cairoLineTo(double x, double y);
+ private native void cairoLineTo(long pointer, double x, double y);
/** relative lineTo */
- private native void cairoRelLineTo(double dx, double dy);
+ private native void cairoRelLineTo(long pointer, double dx, double dy);
/** Cubic curve-to */
- private native void cairoCurveTo(double x1, double y1, double x2, double y2,
+ private native void cairoCurveTo(long pointer, double x1, double y1,
+ double x2, double y2,
double x3, double y3);
/**
* Stroke current path
*/
- private native void cairoStroke();
+ private native void cairoStroke(long pointer);
/**
* Fill current path
*/
- private native void cairoFill();
+ private native void cairoFill(long pointer, double alpha);
/**
* Clip current path
*/
- private native void cairoClip();
+ private native void cairoClip(long pointer);
/**
* Save clip
*/
- private native void cairoPreserveClip();
+ private native void cairoPreserveClip(long pointer);
/**
* Save clip
*/
- private native void cairoResetClip();
+ private native void cairoResetClip(long pointer);
/**
* Set interpolation types
*/
- private native void cairoSurfaceSetFilter(int filter);
+ private native void cairoSurfaceSetFilter(long pointer, int filter);
///////////////////////// TRANSFORMS ///////////////////////////////////
/**
*/
public void setTransform(AffineTransform tx)
{
+ // Transform clip into target space using the old transform.
+ updateClip(transform);
+
+ // Update the native transform.
+ setTransformImpl(tx);
+
+ // Transform the clip back into user space using the inverse new transform.
+ try
+ {
+ updateClip(transform.createInverse());
+ }
+ catch (NoninvertibleTransformException ex)
+ {
+ // TODO: How can we deal properly with this?
+ ex.printStackTrace();
+ }
+
+ if (clip != null)
+ setClip(clip);
+ }
+
+ private void setTransformImpl(AffineTransform tx)
+ {
transform = tx;
if (transform != null)
{
- double[] m = new double[6];
- transform.getMatrix(m);
- cairoSetMatrix(m);
+ double[] m = new double[6];
+ transform.getMatrix(m);
+ cairoSetMatrix(nativePointer, m);
}
}
-
+
public void transform(AffineTransform tx)
{
if (transform == null)
transform = new AffineTransform(tx);
else
transform.concatenate(tx);
- setTransform(transform);
+
if (clip != null)
{
- // FIXME: this should actuall try to transform the shape
- // rather than degrade to bounds.
- Rectangle2D r = clip.getBounds2D();
- double[] coords = new double[]
- {
- r.getX(), r.getY(), r.getX() + r.getWidth(),
- r.getY() + r.getHeight()
- };
- try
- {
- tx.createInverse().transform(coords, 0, coords, 0, 2);
- r.setRect(coords[0], coords[1], coords[2] - coords[0],
- coords[3] - coords[1]);
- clip = r;
- }
- catch (java.awt.geom.NoninvertibleTransformException e)
- {
- }
+ try
+ {
+ AffineTransform clipTransform = tx.createInverse();
+ updateClip(clipTransform);
+ }
+ catch (NoninvertibleTransformException ex)
+ {
+ // TODO: How can we deal properly with this?
+ ex.printStackTrace();
+ }
}
+
+ setTransformImpl(transform);
}
public void rotate(double theta)
{
// FIXME: this should actuall try to transform the shape
// rather than degrade to bounds.
- Rectangle2D r;
-
if (clip instanceof Rectangle2D)
- r = (Rectangle2D) clip;
+ {
+ Rectangle2D r = (Rectangle2D) clip;
+ r.setRect(r.getX() - tx, r.getY() - ty, r.getWidth(),
+ r.getHeight());
+ }
else
- r = clip.getBounds2D();
-
- r.setRect(r.getX() - tx, r.getY() - ty, r.getWidth(), r.getHeight());
- clip = r;
+ {
+ AffineTransform clipTransform =
+ AffineTransform.getTranslateInstance(-tx, -ty);
+ updateClip(clipTransform);
+ }
}
- setTransform(transform);
+ setTransformImpl(transform);
}
public void translate(int x, int y)
{
// Do not touch clip when s == null.
if (s == null)
- return;
+ {
+ // The spec says this should clear the clip. The reference
+ // implementation throws a NullPointerException instead. I think,
+ // in this case we should conform to the specs, as it shouldn't
+ // affect compatibility.
+ setClip(null);
+ return;
+ }
// If the current clip is still null, initialize it.
if (clip == null)
- clip = originalClip;
-
- // This is so common, let's optimize this.
- else if (clip instanceof Rectangle2D && s instanceof Rectangle2D)
+ {
+ clip = getRealBounds();
+ }
+
+ // This is so common, let's optimize this.
+ if (clip instanceof Rectangle2D && s instanceof Rectangle2D)
{
Rectangle2D clipRect = (Rectangle2D) clip;
Rectangle2D r = (Rectangle2D) s;
Rectangle2D.intersect(clipRect, r, clipRect);
- // Call setClip so that subclasses get notified.
setClip(clipRect);
}
else
AffineTransformOp op = new AffineTransformOp(at, getRenderingHints());
BufferedImage texture = op.filter(img, null);
int[] pixels = texture.getRGB(0, 0, width, height, null, 0, width);
- setTexturePixels(pixels, width, height, width);
+ setTexturePixels(nativePointer, pixels, width, height, width);
}
else if (paint instanceof GradientPaint)
{
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());
+ setGradient(nativePointer, 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();
if (stroke instanceof BasicStroke)
{
BasicStroke bs = (BasicStroke) stroke;
- cairoSetLine(bs.getLineWidth(), bs.getEndCap(),
+ cairoSetLine(nativePointer, bs.getLineWidth(), bs.getEndCap(),
bs.getLineJoin(), bs.getMiterLimit());
float[] dashes = bs.getDashArray();
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,
+ cairoSetDash(nativePointer, double_dashes, double_dashes.length,
(double) bs.getDashPhase());
}
else
- cairoSetDash(new double[0], 0, 0.0);
+ cairoSetDash(nativePointer, new double[0], 0, 0.0);
}
}
{
if (fg == null)
fg = Color.BLACK;
- cairoSetRGBAColor(fg.getRed() / 255.0, fg.getGreen() / 255.0,
- fg.getBlue() / 255.0, fg.getAlpha() / 255.0);
+ cairoSetRGBAColor(nativePointer, fg.getRed() / 255.0,
+ fg.getGreen() / 255.0,fg.getBlue() / 255.0,
+ fg.getAlpha() / 255.0);
}
public Color getColor()
public void clipRect(int x, int y, int width, int height)
{
- clip(new Rectangle(x, y, width, height));
+ if (clip == null)
+ setClip(new Rectangle(x, y, width, height));
+ else if (clip instanceof Rectangle)
+ {
+ computeIntersection(x, y, width, height, (Rectangle) clip);
+ setClip(clip);
+ }
+ else
+ clip(new Rectangle(x, y, width, height));
}
public Shape getClip()
{
if (clip == null)
return null;
- else
+ else if (clip instanceof Rectangle2D)
return clip.getBounds2D(); //getClipInDevSpace();
+ else
+ {
+ GeneralPath p = new GeneralPath();
+ PathIterator pi = clip.getPathIterator(new AffineTransform());
+ p.append(pi, false);
+ return p;
+ }
}
public Rectangle getClipBounds()
}
public void setClip(Shape s)
- {
+ {
// The first time the clip is set, save it as the original clip
// to reset to on s == null. We can rely on this being non-null
// because the constructor in subclasses is expected to set the
firstClip = false;
}
- if (s == null)
- clip = originalClip;
- else
- clip = s;
-
- cairoResetClip();
+ clip = s;
+ cairoResetClip(nativePointer);
- cairoNewPath();
- if (clip instanceof Rectangle2D)
+ if (clip != null)
{
- Rectangle2D r = (Rectangle2D) clip;
- cairoRectangle(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ cairoNewPath(nativePointer);
+ if (clip instanceof Rectangle2D)
+ {
+ Rectangle2D r = (Rectangle2D) clip;
+ cairoRectangle(nativePointer, r.getX(), r.getY(), r.getWidth(),
+ r.getHeight());
+ }
+ else
+ walkPath(clip.getPathIterator(null), false);
+
+ cairoClip(nativePointer);
}
- else
- walkPath(clip.getPathIterator(null), false);
-
- cairoClip();
}
public void setBackground(Color c)
if (comp instanceof AlphaComposite)
{
AlphaComposite a = (AlphaComposite) comp;
- cairoSetOperator(a.getRule());
- Color c = getColor();
- setColor(new Color(c.getRed(), c.getGreen(), c.getBlue(),
- (int) (a.getAlpha() * ((float) c.getAlpha()))));
+ cairoSetOperator(nativePointer, a.getRule());
}
else
{
public void draw(Shape s)
{
- if (stroke != null && ! (stroke instanceof BasicStroke))
+ if ((stroke != null && ! (stroke instanceof BasicStroke))
+ || (comp instanceof AlphaComposite
+ && ((AlphaComposite) comp).getAlpha() != 1.0))
{
+ // FIXME: This is a hack to work around BasicStrokes's current
+ // limitations wrt cubic curves.
+ // See CubicSegment.getDisplacedSegments().
+ if (stroke instanceof BasicStroke)
+ {
+ PathIterator flatten = s.getPathIterator(new AffineTransform(),
+ 1.0);
+ GeneralPath p = new GeneralPath();
+ p.append(flatten, false);
+ s = p;
+ }
fill(stroke.createStrokedShape(s));
return;
}
- cairoNewPath();
+ cairoNewPath(nativePointer);
if (s instanceof Rectangle2D)
{
Rectangle2D r = (Rectangle2D) s;
- cairoRectangle(shifted(r.getX(), shiftDrawCalls),
+ cairoRectangle(nativePointer, shifted(r.getX(), shiftDrawCalls),
shifted(r.getY(), shiftDrawCalls), r.getWidth(),
r.getHeight());
}
else
walkPath(s.getPathIterator(null), shiftDrawCalls);
- cairoStroke();
+ cairoStroke(nativePointer);
}
public void fill(Shape s)
{
- cairoNewPath();
+ cairoNewPath(nativePointer);
if (s instanceof Rectangle2D)
{
Rectangle2D r = (Rectangle2D) s;
- cairoRectangle(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ cairoRectangle(nativePointer, r.getX(), r.getY(), r.getWidth(),
+ r.getHeight());
}
else
walkPath(s.getPathIterator(null), false);
- cairoFill();
+ double alpha = 1.0;
+ if (comp instanceof AlphaComposite)
+ alpha = ((AlphaComposite) comp).getAlpha();
+ cairoFill(nativePointer, alpha);
}
/**
public void clearRect(int x, int y, int width, int height)
{
if (bg != null)
- cairoSetRGBAColor(bg.getRed() / 255.0, bg.getGreen() / 255.0,
- bg.getBlue() / 255.0, 1.0);
+ cairoSetRGBAColor(nativePointer, bg.getRed() / 255.0,
+ bg.getGreen() / 255.0, bg.getBlue() / 255.0, 1.0);
fillRect(x, y, width, height);
updateColor();
}
|| hintKey.equals(RenderingHints.KEY_ALPHA_INTERPOLATION))
{
if (hintValue.equals(RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR))
- cairoSurfaceSetFilter(0);
+ cairoSurfaceSetFilter(nativePointer, 0);
else if (hintValue.equals(RenderingHints.VALUE_INTERPOLATION_BILINEAR))
- cairoSurfaceSetFilter(1);
+ cairoSurfaceSetFilter(nativePointer, 1);
else if (hintValue.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED))
- cairoSurfaceSetFilter(2);
+ cairoSurfaceSetFilter(nativePointer, 2);
else if (hintValue.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY))
- cairoSurfaceSetFilter(3);
+ cairoSurfaceSetFilter(nativePointer, 3);
else if (hintValue.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT))
- cairoSurfaceSetFilter(4);
+ cairoSurfaceSetFilter(nativePointer, 4);
}
shiftDrawCalls = hints.containsValue(RenderingHints.VALUE_STROKE_NORMALIZE)
if (hints.containsKey(RenderingHints.KEY_INTERPOLATION))
{
if (hints.containsValue(RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR))
- cairoSurfaceSetFilter(0);
+ cairoSurfaceSetFilter(nativePointer, 0);
else if (hints.containsValue(RenderingHints.VALUE_INTERPOLATION_BILINEAR))
- cairoSurfaceSetFilter(1);
+ cairoSurfaceSetFilter(nativePointer, 1);
}
if (hints.containsKey(RenderingHints.KEY_ALPHA_INTERPOLATION))
{
if (hints.containsValue(RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED))
- cairoSurfaceSetFilter(2);
+ cairoSurfaceSetFilter(nativePointer, 2);
else if (hints.containsValue(RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY))
- cairoSurfaceSetFilter(3);
+ cairoSurfaceSetFilter(nativePointer, 3);
else if (hints.containsValue(RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT))
- cairoSurfaceSetFilter(4);
+ cairoSurfaceSetFilter(nativePointer, 4);
}
shiftDrawCalls = hints.containsValue(RenderingHints.VALUE_STROKE_NORMALIZE)
// other way around. Therefore to get the "user -> pixel" transform
// that cairo wants from "image -> user" transform that we currently
// have, we will need to invert the transformation matrix.
- AffineTransform invertedXform = new AffineTransform();
+ AffineTransform invertedXform;
try
{
+ xform.toString());
}
- // Unrecognized image - convert to a BufferedImage and come back.
+ // Unrecognized image - convert to a BufferedImage
+ // Note - this can get us in trouble when the gdk lock is re-acquired.
+ // for example by VolatileImage. See ComponentGraphics for how we work
+ // around this.
if( !(img instanceof BufferedImage) )
- return this.drawImage(Toolkit.getDefaultToolkit().
- createImage(img.getSource()),
- xform, bgcolor, obs);
+ {
+ ImageProducer source = img.getSource();
+ if (source == null)
+ return false;
+ img = Toolkit.getDefaultToolkit().createImage(source);
+ }
BufferedImage b = (BufferedImage) img;
DataBuffer db;
invertedXform.getMatrix(i2u);
+ double alpha = 1.0;
+ if (comp instanceof AlphaComposite)
+ alpha = ((AlphaComposite) comp).getAlpha();
+
if(db instanceof CairoSurface)
{
- ((CairoSurface)db).drawSurface(this, i2u);
+ ((CairoSurface)db).drawSurface(nativePointer, i2u, alpha);
return true;
}
null, 0, width);
}
- drawPixels(pixels, width, height, width, i2u);
+ drawPixels(nativePointer, pixels, width, height, width, i2u, alpha);
// Cairo seems to lose the current color which must be restored.
updateColor();
{
if (str == null || str.length() == 0)
return;
-
- drawGlyphVector(getFont().createGlyphVector(null, str), x, y);
+ (new TextLayout( str, getFont(), getFontRenderContext() )).
+ draw(this, x, y);
}
public void drawString(String str, int x, int y)
public void drawGlyphVector(GlyphVector gv, float x, float y)
{
- int n = gv.getNumGlyphs ();
- int[] codes = gv.getGlyphCodes (0, n, null);
- float[] positions = gv.getGlyphPositions (0, n, null);
-
- setFont (gv.getFont ());
- cairoDrawGlyphVector( (GdkFontPeer)getFont().getPeer(), x, y, n, codes, positions);
+ double alpha = 1.0;
+ if (comp instanceof AlphaComposite)
+ alpha = ((AlphaComposite) comp).getAlpha();
+ if (gv instanceof FreetypeGlyphVector && alpha == 1.0)
+ {
+ int n = gv.getNumGlyphs ();
+ int[] codes = gv.getGlyphCodes (0, n, null);
+ float[] positions = gv.getGlyphPositions (0, n, null);
+
+ setFont (gv.getFont ());
+ cairoDrawGlyphVector(nativePointer, (GdkFontPeer)getFont().getPeer(),
+ x, y, n, codes, positions);
+ }
+ else
+ {
+ translate(x, y);
+ fill(gv.getOutline());
+ translate(-x, -y);
+ }
}
public void drawString(AttributedCharacterIterator ci, float x, float y)
for (int i = 0; i < pixels.length; i++)
pixels[i] |= 0xFF000000;
- drawPixels(pixels, r.getWidth(), r.getHeight(), r.getWidth(), i2u);
+ double alpha = 1.0;
+ if (comp instanceof AlphaComposite)
+ alpha = ((AlphaComposite) comp).getAlpha();
+ drawPixels(nativePointer, pixels, r.getWidth(), r.getHeight(),
+ r.getWidth(), i2u, alpha);
// Cairo seems to lose the current color which must be restored.
updateColor();
double y = 0;
double[] coords = new double[6];
- cairoSetFillRule(p.getWindingRule());
+ cairoSetFillRule(nativePointer, p.getWindingRule());
for (; ! p.isDone(); p.next())
{
int seg = p.currentSegment(coords);
case PathIterator.SEG_MOVETO:
x = shifted(coords[0], doShift);
y = shifted(coords[1], doShift);
- cairoMoveTo(x, y);
+ cairoMoveTo(nativePointer, x, y);
break;
case PathIterator.SEG_LINETO:
x = shifted(coords[0], doShift);
y = shifted(coords[1], doShift);
- cairoLineTo(x, y);
+ cairoLineTo(nativePointer, x, y);
break;
case PathIterator.SEG_QUADTO:
// splitting a quadratic bezier into a cubic:
x = shifted(coords[2], doShift);
y = shifted(coords[3], doShift);
- cairoCurveTo(x1, y1, x2, y2, x, y);
+ cairoCurveTo(nativePointer, x1, y1, x2, y2, x, y);
break;
case PathIterator.SEG_CUBICTO:
x = shifted(coords[4], doShift);
y = shifted(coords[5], doShift);
- cairoCurveTo(shifted(coords[0], doShift),
+ cairoCurveTo(nativePointer, shifted(coords[0], doShift),
shifted(coords[1], doShift),
shifted(coords[2], doShift),
shifted(coords[3], doShift), x, y);
break;
case PathIterator.SEG_CLOSE:
- cairoClosePath();
+ cairoClosePath(nativePointer);
break;
}
}
return db.getData();
}
+
+ /**
+ * Helper method to transform the clip. This is called by the various
+ * transformation-manipulation methods to update the clip (which is in
+ * userspace) accordingly.
+ *
+ * The transform usually is the inverse transform that was applied to the
+ * graphics object.
+ *
+ * @param t the transform to apply to the clip
+ */
+ private void updateClip(AffineTransform t)
+ {
+ if (clip == null)
+ return;
+
+ if (! (clip instanceof GeneralPath))
+ clip = new GeneralPath(clip);
+
+ GeneralPath p = (GeneralPath) clip;
+ p.transform(t);
+ }
+
+ private static Rectangle computeIntersection(int x, int y, int w, int h,
+ Rectangle rect)
+ {
+ int x2 = (int) rect.x;
+ int y2 = (int) rect.y;
+ int w2 = (int) rect.width;
+ int h2 = (int) rect.height;
+
+ int dx = (x > x2) ? x : x2;
+ int dy = (y > y2) ? y : y2;
+ int dw = (x + w < x2 + w2) ? (x + w - dx) : (x2 + w2 - dx);
+ int dh = (y + h < y2 + h2) ? (y + h - dy) : (y2 + h2 - dy);
+
+ if (dw >= 0 && dh >= 0)
+ rect.setBounds(dx, dy, dw, dh);
+ else
+ rect.setBounds(0, 0, 0, 0);
+
+ return rect;
+ }
}
/**
* Allocates and clears the buffer and creates the cairo surface.
* @param width, height - the image size
- * @param stride - the buffer row stride.
+ * @param stride - the buffer row stride. (in ints)
*/
private native void create(int width, int height, int stride);
/**
* Destroys the cairo surface and frees the buffer.
*/
- private native void destroy();
+ private native void destroy(long surfacePointer, long bufferPointer);
/**
* Gets buffer elements
*/
- private native int nativeGetElem(int i);
+ private native int nativeGetElem(long bufferPointer, int i);
/**
* Sets buffer elements.
*/
- private native void nativeSetElem(int i, int val);
+ private native void nativeSetElem(long bufferPointer, int i, int val);
/**
* Draws this image to a given CairoGraphics context,
* with an affine transform given by i2u.
*/
- public native void drawSurface(CairoGraphics2D context, double[] i2u);
+ public native void nativeDrawSurface(long surfacePointer, long contextPointer,
+ double[] i2u, double alpha);
+
+ public void drawSurface(long contextPointer, double[] i2u, double alpha)
+ {
+ nativeDrawSurface(surfacePointer, contextPointer, i2u, alpha);
+ }
/**
* getPixels -return the pixels as a java array.
*/
- native int[] getPixels(int size);
+ native int[] nativeGetPixels(long bufferPointer, int size);
+
+ public int[] getPixels(int size)
+ {
+ return nativeGetPixels(bufferPointer, size);
+ }
/**
* getPixels -return the pixels as a java array.
*/
- native void setPixels(int[] pixels);
+ native void nativeSetPixels(long bufferPointer, int[] pixels);
+
+ public void setPixels(int[] pixels)
+ {
+ nativeSetPixels(bufferPointer, pixels);
+ }
- native long getFlippedBuffer(int size);
+ native long getFlippedBuffer(long bufferPointer, int size);
/**
* Create a cairo_surface_t with specified width and height.
* The format will be ARGB32 with premultiplied alpha and native bit
* and word ordering.
*/
- CairoSurface(int width, int height)
+ public CairoSurface(int width, int height)
{
super(DataBuffer.TYPE_INT, width * height);
this.width = width;
this.height = height;
- create(width, height, width * 4);
+ create(width, height, width);
if(surfacePointer == 0 || bufferPointer == 0)
throw new Error("Could not allocate bitmap.");
width = image.width;
height = image.height;
- create(width, height, width * 4);
+ create(width, height, width);
if(surfacePointer == 0 || bufferPointer == 0)
throw new Error("Could not allocate bitmap.");
public void dispose()
{
if(surfacePointer != 0)
- destroy();
+ destroy(surfacePointer, bufferPointer);
}
/**
*/
public GtkImage getGtkImage()
{
- return new GtkImage( width, height, getFlippedBuffer( width * height ));
+ return new GtkImage( width, height,
+ getFlippedBuffer(bufferPointer, width * height ));
}
/**
{
if(bank != 0 || i < 0 || i >= width*height)
throw new IndexOutOfBoundsException(i+" size: "+width*height);
- return nativeGetElem(i);
+ return nativeGetElem(bufferPointer, i);
}
/**
{
if(bank != 0 || i < 0 || i >= width*height)
throw new IndexOutOfBoundsException(i+" size: "+width*height);
- nativeSetElem(i, val);
+ nativeSetElem(bufferPointer, i, val);
}
/**
* Creates a cairo_t drawing context, returns the pointer as a long.
* Used by CairoSurfaceGraphics.
*/
- native long newCairoContext();
+ native long nativeNewCairoContext(long surfacePointer);
+
+ public long newCairoContext()
+ {
+ return nativeNewCairoContext(surfacePointer);
+ }
/**
* Copy an area of the surface. Expects parameters must be within bounds.
* Count on a segfault otherwise.
*/
- native void copyAreaNative(int x, int y, int width, int height,
- int dx, int dy, int stride);
+ native void copyAreaNative2(long bufferPointer, int x, int y, int width,
+ int height, int dx, int dy, int stride);
+ public void copyAreaNative(int x, int y, int width,
+ int height, int dx, int dy, int stride)
+ {
+ copyAreaNative2(bufferPointer, x, y, width, height, dx, dy, stride);
+ }
}
import java.awt.Graphics;
import java.awt.Color;
+import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Point;
import java.awt.Graphics2D;
this.surface = surface;
cairo_t = surface.newCairoContext();
setup( cairo_t );
- setClip(0, 0, surface.width, surface.height);
}
/**
surface = copyFrom.surface;
cairo_t = surface.newCairoContext();
copy( copyFrom, cairo_t );
- setClip(0, 0, surface.width, surface.height);
}
public Graphics create()
public GraphicsConfiguration getDeviceConfiguration()
{
- throw new UnsupportedOperationException();
+ return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
}
protected Rectangle2D getRealBounds()
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
+import java.awt.Toolkit;
import java.awt.Point;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
import java.awt.image.ImagingOpException;
import java.awt.image.RenderedImage;
private GtkComponentPeer component;
protected long cairo_t;
+ private static ThreadLocal hasLock = new ThreadLocal();
+ private static Integer ONE = Integer.valueOf(1);
+
+ private void lock()
+ {
+ Integer i = (Integer) hasLock.get();
+ if (i == null)
+ {
+ start_gdk_drawing();
+ hasLock.set(ONE);
+ }
+ else
+ hasLock.set(Integer.valueOf(i.intValue() + 1));
+ }
+
+ private void unlock()
+ {
+ Integer i = (Integer) hasLock.get();
+ if (i == null)
+ throw new IllegalStateException();
+ if (i == ONE)
+ {
+ hasLock.set(null);
+ end_gdk_drawing();
+ }
+ else
+ hasLock.set(Integer.valueOf(i.intValue() - 1));
+ }
+
ComponentGraphics()
{
}
*/
public void dispose()
{
- disposeSurface(nativePointer);
super.dispose();
+ disposeSurface(nativePointer);
}
/**
int width, int height, int dx, int dy);
private native void drawVolatile(GtkComponentPeer component,
- Image vimg, int x, int y,
+ long vimg, int x, int y,
int width, int height);
/**
*/
public void draw(Shape s)
{
- start_gdk_drawing();
- super.draw(s);
- end_gdk_drawing();
+ lock();
+ try
+ {
+ super.draw(s);
+ }
+ finally
+ {
+ unlock();
+ }
}
public void fill(Shape s)
{
- start_gdk_drawing();
- super.fill(s);
- end_gdk_drawing();
+ lock();
+ try
+ {
+ super.fill(s);
+ }
+ finally
+ {
+ unlock();
+ }
}
public void drawRenderedImage(RenderedImage image, AffineTransform xform)
{
- start_gdk_drawing();
- super.drawRenderedImage(image, xform);
- end_gdk_drawing();
+ lock();
+ try
+ {
+ super.drawRenderedImage(image, xform);
+ }
+ finally
+ {
+ unlock();
+ }
}
protected boolean drawImage(Image img, AffineTransform xform,
Color bgcolor, ImageObserver obs)
{
- start_gdk_drawing();
- boolean rv = super.drawImage(img, xform, bgcolor, obs);
- end_gdk_drawing();
+ boolean rv;
+ lock();
+ try
+ {
+ rv = super.drawImage(img, xform, bgcolor, obs);
+ }
+ finally
+ {
+ unlock();
+ }
return rv;
}
public void drawGlyphVector(GlyphVector gv, float x, float y)
{
- start_gdk_drawing();
- super.drawGlyphVector(gv, x, y);
- end_gdk_drawing();
+ lock();
+ try
+ {
+ super.drawGlyphVector(gv, x, y);
+ }
+ finally
+ {
+ unlock();
+ }
}
public boolean drawImage(Image img, int x, int y, ImageObserver observer)
{
- if( img instanceof GtkVolatileImage )
+ // If it is a GtkVolatileImage with an "easy" transform then
+ // draw directly. Always pass a BufferedImage to super to avoid
+ // deadlock (see Note in CairoGraphics.drawImage()).
+ if (img instanceof GtkVolatileImage)
{
- drawVolatile( component, img, x, y - 20,
- ((GtkVolatileImage)img).width,
- ((GtkVolatileImage)img).height );
- return true;
- }
- return super.drawImage( img, x, y, observer );
+ GtkVolatileImage vimg = (GtkVolatileImage) img;
+ int type = transform.getType();
+ if (type == AffineTransform.TYPE_IDENTITY)
+ {
+ drawVolatile(component, vimg.nativePointer,
+ x, y, vimg.width, vimg.height);
+ return true;
+ }
+ else if (type == AffineTransform.TYPE_TRANSLATION)
+ {
+ x += transform.getTranslateX();
+ y += transform.getTranslateY();
+ drawVolatile(component, vimg.nativePointer,
+ x, y, vimg.width, vimg.height);
+ return true;
+ }
+ else
+ return super.drawImage(vimg.getSnapshot(), x, y, observer);
+ }
+
+ BufferedImage bimg;
+ if (img instanceof BufferedImage)
+ bimg = (BufferedImage) img;
+ else
+ {
+ ImageProducer source = img.getSource();
+ if (source == null)
+ return false;
+ bimg = (BufferedImage) Toolkit.getDefaultToolkit().createImage(source);
+ }
+ return super.drawImage(bimg, x, y, observer);
}
public boolean drawImage(Image img, int x, int y, int width, int height,
ImageObserver observer)
{
- if( img instanceof GtkVolatileImage )
+ // If it is a GtkVolatileImage with an "easy" transform then
+ // draw directly. Always pass a BufferedImage to super to avoid
+ // deadlock (see Note in CairoGraphics.drawImage()).
+ if (img instanceof GtkVolatileImage)
+ {
+ GtkVolatileImage vimg = (GtkVolatileImage) img;
+ int type = transform.getType();
+ if (type == AffineTransform.TYPE_IDENTITY)
+ {
+ drawVolatile(component, vimg.nativePointer,
+ x, y, width, height);
+ return true;
+ }
+ else if (type == AffineTransform.TYPE_TRANSLATION)
+ {
+ x += transform.getTranslateX();
+ y += transform.getTranslateY();
+ drawVolatile(component, vimg.nativePointer,
+ x, y, width, height);
+ return true;
+ }
+ else
+ return super.drawImage(vimg.getSnapshot(), x, y,
+ width, height, observer);
+ }
+
+ BufferedImage bimg;
+ if (img instanceof BufferedImage)
+ bimg = (BufferedImage) img;
+ else
{
- drawVolatile( component, img, x, y - 20,
- width, height );
- return true;
- }
- return super.drawImage( img, x, y, width, height, observer );
+ ImageProducer source = img.getSource();
+ if (source == null)
+ return false;
+ bimg = (BufferedImage) Toolkit.getDefaultToolkit().createImage(source);
+ }
+ return super.drawImage(bimg, x, y, width, height, observer);
}
}
private Font font;
private GdkFontPeer peer; // ATTN: Accessed from native code.
+ private Rectangle2D logicalBounds;
+
+ private float[] glyphPositions;
/**
* The string represented by this GlyphVector.
*/
*/
private AffineTransform[] glyphTransforms;
+ private GlyphMetrics[] metricsCache;
+
/**
* Create a glyphvector from a given (Freetype) font and a String.
*/
public FreetypeGlyphVector(Font f, String s, FontRenderContext frc)
{
+ this(f, s, frc, Font.LAYOUT_LEFT_TO_RIGHT);
+ }
+
+ /**
+ * Create a glyphvector from a given (Freetype) font and a String.
+ */
+ public FreetypeGlyphVector(Font f, String s, FontRenderContext frc,
+ int flags)
+ {
this.s = s;
this.font = f;
this.frc = frc;
peer = (GdkFontPeer)font.getPeer();
getGlyphs();
+ if( flags == Font.LAYOUT_RIGHT_TO_LEFT )
+ {
+ // reverse the glyph ordering.
+ int[] temp = new int[ nGlyphs ];
+ for(int i = 0; i < nGlyphs; i++)
+ temp[ i ] = glyphCodes[ nGlyphs - i - 1];
+ glyphCodes = temp;
+ }
performDefaultLayout();
}
{
nGlyphs = s.codePointCount( 0, s.length() );
glyphCodes = new int[ nGlyphs ];
+ int[] codePoints = new int[ nGlyphs ];
int stringIndex = 0;
+
for(int i = 0; i < nGlyphs; i++)
{
- glyphCodes[i] = getGlyph( s.codePointAt(stringIndex) );
+ codePoints[i] = s.codePointAt( stringIndex );
// UTF32 surrogate handling
- if( s.codePointAt( stringIndex ) != (int)s.charAt( stringIndex ) )
+ if( codePoints[i] != (int)s.charAt( stringIndex ) )
stringIndex ++;
stringIndex ++;
}
+
+ glyphCodes = getGlyphs( codePoints );
}
/**
* Returns the glyph code within the font for a given character
*/
- public native int getGlyph(int codepoint);
+ public native int[] getGlyphs(int[] codepoints);
/**
* Returns the kerning of a glyph pair
*/
public void performDefaultLayout()
{
+ logicalBounds = null; // invalidate caches.
+ glyphPositions = null;
+
glyphTransforms = new AffineTransform[ nGlyphs ];
double x = 0;
+
for(int i = 0; i < nGlyphs; i++)
{
GlyphMetrics gm = getGlyphMetrics( i );
- Rectangle2D r = gm.getBounds2D();
glyphTransforms[ i ] = AffineTransform.getTranslateInstance(x, 0);
x += gm.getAdvanceX();
if( i > 0 )
gm.getAdvanceX(), r.getHeight() );
}
+ /*
+ * FIXME: Not all glyph types are supported.
+ * (The JDK doesn't really seem to do so either)
+ */
+ public void setupGlyphMetrics()
+ {
+ metricsCache = new GlyphMetrics[ nGlyphs ];
+
+ for(int i = 0; i < nGlyphs; i++)
+ {
+ GlyphMetrics gm = (GlyphMetrics)
+ peer.getGlyphMetrics( glyphCodes[ i ] );
+ if( gm == null )
+ {
+ double[] val = getMetricsNative( glyphCodes[ i ] );
+ if( val == null )
+ gm = null;
+ else
+ {
+ gm = new GlyphMetrics( true,
+ (float)val[1],
+ (float)val[2],
+ new Rectangle2D.Double
+ ( val[3], val[4],
+ val[5], val[6] ),
+ GlyphMetrics.STANDARD );
+ peer.putGlyphMetrics( glyphCodes[ i ], gm );
+ }
+ }
+ metricsCache[ i ] = gm;
+ }
+ }
+
/**
* Returns the metrics of a single glyph.
*/
public GlyphMetrics getGlyphMetrics(int glyphIndex)
{
- double[] val = getMetricsNative( glyphCodes[ glyphIndex ] );
- if( val == null )
- return null;
-
- return new GlyphMetrics( true, (float)val[1], (float)val[2],
- new Rectangle2D.Double( val[3], val[4],
- val[5], val[6] ),
- GlyphMetrics.STANDARD );
+ if( metricsCache == null )
+ setupGlyphMetrics();
+
+ return metricsCache[ glyphIndex ];
}
/**
public float[] getGlyphPositions(int beginGlyphIndex, int numEntries,
float[] positionReturn)
{
+ if( glyphPositions != null )
+ return glyphPositions;
+
float[] rval;
if( positionReturn == null )
rval[i * 2 + 1] = (float)p.getY();
}
+ glyphPositions = rval;
return rval;
}
{
if( nGlyphs == 0 )
return new Rectangle2D.Double(0, 0, 0, 0);
+ if( logicalBounds != null )
+ return logicalBounds;
Rectangle2D rect = (Rectangle2D)getGlyphLogicalBounds( 0 );
for( int i = 1; i < nGlyphs; i++ )
- rect = rect.createUnion( (Rectangle2D)getGlyphLogicalBounds( i ) );
+ {
+ Rectangle2D r2 = (Rectangle2D)getGlyphLogicalBounds( i );
+ Point2D p = getGlyphPosition( i );
+ r2.setRect( p.getX(), p.getY(), r2.getWidth(), r2.getHeight() );
+ rect = rect.createUnion( r2 );
+ }
+ logicalBounds = rect;
return rect;
}
public Shape getOutline(float x, float y)
{
AffineTransform tx = AffineTransform.getTranslateInstance( x, y );
- return tx.createTransformedShape( getOutline() );
+ GeneralPath gp = (GeneralPath)getOutline();
+ gp.transform( tx );
+ return gp;
}
/**
// FIXME: Scaling, etc.?
glyphTransforms[ glyphIndex ].setToTranslation( newPos.getX(),
newPos.getY() );
+ logicalBounds = null;
+ glyphPositions = null;
}
/**
public void setGlyphTransform(int glyphIndex, AffineTransform newTX)
{
glyphTransforms[ glyphIndex ].setTransform( newTX );
+ logicalBounds = null;
+ glyphPositions = null;
}
}
import java.util.Map;
import java.util.ResourceBundle;
import java.nio.ByteBuffer;
+import java.util.HashMap;
public class GdkFontPeer extends ClasspathFontPeer
{
static native void initStaticState();
private final int native_state = GtkGenericPeer.getUniqueInteger ();
private static ResourceBundle bundle;
+
+ /**
+ * Cache GlyphMetrics objects.
+ */
+ private HashMap metricsCache;
static
{
super(name, style, size);
initState ();
setFont (this.familyName, this.style, (int)this.size);
+ metricsCache = new HashMap();
}
public GdkFontPeer (String name, Map attributes)
super(name, attributes);
initState ();
setFont (this.familyName, this.style, (int)this.size);
+ metricsCache = new HashMap();
}
/**
public byte getBaselineFor (Font font, char c)
{
- throw new UnsupportedOperationException ();
+ // FIXME: Actually check.
+ return Font.ROMAN_BASELINE;
}
- protected class GdkFontLineMetrics extends LineMetrics
+ private static class GdkFontLineMetrics extends LineMetrics
{
- FontMetrics fm;
- int nchars;
+ private FontMetrics fm;
+ private int nchars;
+ private float strikethroughOffset, strikethroughThickness,
+ underlineOffset, underlineThickness;
- public GdkFontLineMetrics (FontMetrics m, int n)
+ public GdkFontLineMetrics (GdkFontPeer fp, FontMetrics m, int n)
{
fm = m;
nchars = n;
+ strikethroughOffset = 0f;
+ underlineOffset = 0f;
+ strikethroughThickness = ((float)fp.getSize(null)) / 12f;
+ underlineThickness = strikethroughThickness;
}
public float getAscent()
}
public int getBaselineIndex()
- {
+ {
+ // FIXME
return Font.ROMAN_BASELINE;
}
public LineMetrics getLineMetrics (Font font, CharacterIterator ci,
int begin, int limit, FontRenderContext rc)
{
- return new GdkFontLineMetrics (getFontMetrics (font), limit - begin);
+ return new GdkFontLineMetrics (this, getFontMetrics (font), limit - begin);
}
public Rectangle2D getMaxCharBounds (Font font, FontRenderContext rc)
char[] chars, int start, int limit,
int flags)
{
- int nchars = (limit - start) + 1;
- char[] nc = new char[nchars];
-
- for (int i = 0; i < nchars; ++i)
- nc[i] = chars[start + i];
-
- return createGlyphVector (font, frc,
- new StringCharacterIterator (new String (nc)));
+ return new FreetypeGlyphVector( font, new String( chars, start,
+ limit - start),
+ frc, flags);
}
public LineMetrics getLineMetrics (Font font, String str,
FontRenderContext frc)
{
- return new GdkFontLineMetrics (getFontMetrics (font), str.length ());
+ return new GdkFontLineMetrics (this, getFontMetrics (font), str.length ());
}
public FontMetrics getFontMetrics (Font font)
// the metrics cache.
return Toolkit.getDefaultToolkit().getFontMetrics (font);
}
+
+ /**
+ * Returns a cached GlyphMetrics object for a given glyphcode,
+ * or null if it doesn't exist in the cache.
+ */
+ GlyphMetrics getGlyphMetrics( int glyphCode )
+ {
+ return (GlyphMetrics)metricsCache.get( new Integer( glyphCode ) );
+ }
+
+ /**
+ * Put a GlyphMetrics object in the cache.
+ */
+ void putGlyphMetrics( int glyphCode, Object metrics )
+ {
+ metricsCache.put( new Integer( glyphCode ), metrics );
+ }
}
native void pumpBytes (byte[] bytes, int len) throws IOException;
native void pumpDone () throws IOException;
native void finish (boolean needsClose);
- static native void streamImage(int[] bytes, String format, int width, int height, boolean hasAlpha, DataOutput sink);
-
+
+ /**
+ * Converts given image to bytes.
+ * Will call the GdkPixbufWriter for each chunk.
+ */
+ static native void streamImage(int[] bytes, String format,
+ int width, int height,
+ boolean hasAlpha, GdkPixbufWriter writer);
+
// gdk-pixbuf provids data in RGBA format
static final ColorModel cm = new DirectColorModel (32, 0xff000000,
0x00ff0000,
}
private static class GdkPixbufWriter
- extends ImageWriter
+ extends ImageWriter implements Runnable
{
String ext;
public GdkPixbufWriter(GdkPixbufWriterSpi ownerSpi, Object ext)
model = img.getColorModel();
}
+ Thread workerThread = new Thread(this, "GdkPixbufWriter");
+ workerThread.start();
processImageStarted(1);
synchronized(pixbufLock)
{
streamImage(pixels, this.ext, width, height, model.hasAlpha(),
- (DataOutput) this.getOutput());
+ this);
}
+ synchronized(data)
+ {
+ data.add(DATADONE);
+ data.notifyAll();
+ }
+
+ while (workerThread.isAlive())
+ {
+ try
+ {
+ workerThread.join();
+ }
+ catch (InterruptedException ioe)
+ {
+ // Ignored.
+ }
+ }
+
+ if (exception != null)
+ throw exception;
+
processImageComplete();
}
+
+ /**
+ * Object marking end of data from native streamImage code.
+ */
+ private static final Object DATADONE = new Object();
+
+ /**
+ * Holds the data gotten from the native streamImage code.
+ * A worker thread will pull data out.
+ * Needs to be synchronized for access.
+ * The special object DATADONE is added when all data has been delivered.
+ */
+ private ArrayList data = new ArrayList();
+
+ /**
+ * Holds any IOException thrown by the run method that needs
+ * to be rethrown by the write method.
+ */
+ private IOException exception;
+
+ /** Callback for streamImage native code. **/
+ private void write(byte[] bs)
+ {
+ synchronized(data)
+ {
+ data.add(bs);
+ data.notifyAll();
+ }
+ }
+
+ public void run()
+ {
+ boolean done = false;
+ while (!done)
+ {
+ synchronized(data)
+ {
+ while (data.isEmpty())
+ {
+ try
+ {
+ data.wait();
+ }
+ catch (InterruptedException ie)
+ {
+ /* ignore */
+ }
+ }
+
+ Object o = data.remove(0);
+ if (o == DATADONE)
+ done = true;
+ else
+ {
+ DataOutput out = (DataOutput) getOutput();
+ try
+ {
+ out.write((byte[]) o);
+ }
+ catch (IOException ioe)
+ {
+ // We are only interested in the first exception.
+ if (exception == null)
+ exception = ioe;
+ }
+ }
+ }
+ }
+ }
}
private static class GdkPixbufReader
/* GdkTextLayout.java
- Copyright (C) 2003, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2005, 2006 Free Software Foundation, Inc.
This file is part of GNU Classpath.
private native void dispose ();
- private native void cairoDrawGdkTextLayout(CairoGraphics2D g, float x, float y);
+ private native void cairoDrawGdkTextLayout(long cg2d, float x, float y);
static native void initStaticState();
public void draw (Graphics2D g2, float x, float y)
{
- cairoDrawGdkTextLayout((CairoGraphics2D)g2, x, y);
+ cairoDrawGdkTextLayout(((CairoGraphics2D) g2).nativePointer, x, y);
}
public TextHitInfo getStrongCaret (TextHitInfo hit1,
native long init(GtkComponentPeer component, int width, int height);
- native void destroy();
+ native void destroy(long pointer);
- native int[] getPixels();
+ native int[] nativeGetPixels(long pointer);
+ public int[] getPixels()
+ {
+ return nativeGetPixels(nativePointer);
+ }
+
+ native void nativeCopyArea(long pointer, int x, int y, int w, int h, int dx,
+ int dy );
+ public void copyArea(int x, int y, int w, int h, int dx, int dy)
+ {
+ nativeCopyArea(nativePointer, x, y, w, h, dx, dy);
+ }
- native void copyArea( int x, int y, int w, int h, int dx, int dy );
+ native void nativeDrawVolatile(long pointer, long srcPtr, int x, int y,
+ int w, int h );
+ public void drawVolatile(long srcPtr, int x, int y, int w, int h )
+ {
+ nativeDrawVolatile(nativePointer, srcPtr, x, y, w, h);
+ }
- native void drawVolatile( long ptr, int x, int y, int w, int h );
-
public GtkVolatileImage(GtkComponentPeer component,
int width, int height, ImageCapabilities caps)
{
public void dispose()
{
- destroy();
+ destroy(nativePointer);
}
public BufferedImage getSnapshot()
this.owner = img;
cairo_t = initFromVolatile( owner.nativePointer, img.width, img.height );
setup( cairo_t );
- setClip( new Rectangle( 0, 0, img.width, img.height) );
}
private VolatileImageGraphics(VolatileImageGraphics copy)
{
this.owner = copy.owner;
- initFromVolatile( owner.nativePointer, owner.width, owner.height );
- setClip( new Rectangle( 0, 0, owner.width, owner.height) );
+ cairo_t = initFromVolatile(owner.nativePointer, owner.width, owner.height);
copy( copy, cairo_t );
}
}
return super.drawImage( img, x, y, width, height, observer );
}
+
+ protected Rectangle2D getRealBounds()
+ {
+ return new Rectangle2D.Double(0, 0, owner.width, owner.height);
+ }
}
--- /dev/null
+/* IndexListParser.java --
+ Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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.net;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.jar.JarFile;
+
+/**
+ * The INDEX.LIST file contains sections each separated by a blank line.
+ * Each section defines the content of a jar, with a
+ * header defining the jar file path name, followed by a list of paths.
+ * The jar file paths are relative to the codebase of the root jar.
+ *
+ Specification
+ index file : version-info blankline section*
+ version-info : JarIndex-Version: version-number
+ version-number : digit+{.digit+}*
+ section : body blankline
+ body : header name*
+ header : char+.jar newline
+ name : char+ newline
+
+ * @author langel at redhat dot com
+ */
+public class IndexListParser
+{
+ public static final String JAR_INDEX_FILE = "META-INF/INDEX.LIST";
+ public static final String JAR_INDEX_VERSION_KEY = "JarIndex-Version: ";
+
+ double versionNumber;
+ // Map each jar to the prefixes defined for the jar.
+ // This is intentionally kept in insertion order.
+ LinkedHashMap prefixes = new LinkedHashMap();
+
+ /**
+ * Parses the given jarfile's INDEX.LIST file if it exists.
+ *
+ * @param jarfile - the given jar file
+ * @param baseJarURL - the codebase of the jar file
+ * @param baseURL - the base url for the headers
+ */
+ public IndexListParser(JarFile jarfile, URL baseJarURL, URL baseURL)
+ {
+ try
+ {
+ // Parse INDEX.LIST if it exists
+ if (jarfile.getEntry(JAR_INDEX_FILE) != null)
+ {
+ BufferedReader br = new BufferedReader(new InputStreamReader(new URL(baseJarURL,
+ JAR_INDEX_FILE).openStream()));
+
+ // Must start with version info
+ String line = br.readLine();
+ if (!line.startsWith(JAR_INDEX_VERSION_KEY))
+ return;
+ versionNumber = Double.parseDouble(line.substring(JAR_INDEX_VERSION_KEY.length()).trim());
+
+ // Blank line must be next
+ line = br.readLine();
+ if (! "".equals(line))
+ {
+ clearAll();
+ return;
+ }
+
+ // May contain sections.
+ while ((line = br.readLine()) != null)
+ {
+ URL jarURL = new URL(baseURL, line);
+ HashSet values = new HashSet();
+
+ // Read the names in the section.
+ while ((line = br.readLine()) != null)
+ {
+ // Stop at section boundary.
+ if ("".equals(line))
+ break;
+ values.add(line.trim());
+ }
+ prefixes.put(jarURL, values);
+ // Might have seen an early EOF.
+ if (line == null)
+ break;
+ }
+
+ br.close();
+ }
+ // else INDEX.LIST does not exist
+ }
+ catch (Exception ex)
+ {
+ clearAll();
+ }
+ }
+
+ /**
+ * Clears all the variables. This is called when parsing fails.
+ */
+ void clearAll()
+ {
+ versionNumber = 0;
+ prefixes = null;
+ }
+
+ /**
+ * Gets the version info for the file.
+ *
+ * @return the version info.
+ */
+ public String getVersionInfo()
+ {
+ return JAR_INDEX_VERSION_KEY + getVersionNumber();
+ }
+
+ /**
+ * Gets the version number of the file.
+ *
+ * @return the version number.
+ */
+ public double getVersionNumber()
+ {
+ return versionNumber;
+ }
+
+ /**
+ * Gets the map of all the headers found in the file.
+ * The keys in the map are URLs of jars. The values in the map
+ * are Sets of package prefixes (and top-level file names), as
+ * specifed in INDEX.LIST.
+ *
+ * @return an map of all the headers, or null if no INDEX.LIST was found
+ */
+ public LinkedHashMap getHeaders()
+ {
+ return prefixes;
+ }
+}
#endif
JNIEXPORT jlong JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_init (JNIEnv *env, jobject, jlong);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_disposeNative (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_drawPixels (JNIEnv *env, jobject, jintArray, jint, jint, jint, jdoubleArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_setGradient (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jint, jint, jint, jint, jint, jint, jint, jint, jboolean);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_setTexturePixels (JNIEnv *env, jobject, jintArray, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetMatrix (JNIEnv *env, jobject, jdoubleArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetOperator (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetRGBAColor (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetFillRule (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetLine (JNIEnv *env, jobject, jdouble, jint, jint, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetDash (JNIEnv *env, jobject, jdoubleArray, jint, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoDrawGlyphVector (JNIEnv *env, jobject, jobject, jfloat, jfloat, jint, jintArray, jfloatArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRelCurveTo (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRectangle (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoNewPath (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoClosePath (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoMoveTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRelMoveTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoLineTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRelLineTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoCurveTo (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoStroke (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoFill (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoClip (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoPreserveClip (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoResetClip (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSurfaceSetFilter (JNIEnv *env, jobject, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_disposeNative (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_drawPixels (JNIEnv *env, jobject, jlong, jintArray, jint, jint, jint, jdoubleArray, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_setGradient (JNIEnv *env, jobject, jlong, jdouble, jdouble, jdouble, jdouble, jint, jint, jint, jint, jint, jint, jint, jint, jboolean);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_setTexturePixels (JNIEnv *env, jobject, jlong, jintArray, jint, jint, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetMatrix (JNIEnv *env, jobject, jlong, jdoubleArray);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetOperator (JNIEnv *env, jobject, jlong, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetRGBAColor (JNIEnv *env, jobject, jlong, jdouble, jdouble, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetFillRule (JNIEnv *env, jobject, jlong, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetLine (JNIEnv *env, jobject, jlong, jdouble, jint, jint, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSetDash (JNIEnv *env, jobject, jlong, jdoubleArray, jint, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoDrawGlyphVector (JNIEnv *env, jobject, jlong, jobject, jfloat, jfloat, jint, jintArray, jfloatArray);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRelCurveTo (JNIEnv *env, jobject, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRectangle (JNIEnv *env, jobject, jlong, jdouble, jdouble, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoNewPath (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoClosePath (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoMoveTo (JNIEnv *env, jobject, jlong, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRelMoveTo (JNIEnv *env, jobject, jlong, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoLineTo (JNIEnv *env, jobject, jlong, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoRelLineTo (JNIEnv *env, jobject, jlong, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoCurveTo (JNIEnv *env, jobject, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoStroke (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoFill (JNIEnv *env, jobject, jlong, jdouble);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoClip (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoPreserveClip (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoResetClip (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoGraphics2D_cairoSurfaceSetFilter (JNIEnv *env, jobject, jlong, jint);
#ifdef __cplusplus
}
#endif
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_create (JNIEnv *env, jobject, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_destroy (JNIEnv *env, jobject);
-JNIEXPORT jint JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeGetElem (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeSetElem (JNIEnv *env, jobject, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_drawSurface (JNIEnv *env, jobject, jobject, jdoubleArray);
-JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_getPixels (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_setPixels (JNIEnv *env, jobject, jintArray);
-JNIEXPORT jlong JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_getFlippedBuffer (JNIEnv *env, jobject, jint);
-JNIEXPORT jlong JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_newCairoContext (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_copyAreaNative (JNIEnv *env, jobject, jint, jint, jint, jint, jint, jint, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_destroy (JNIEnv *env, jobject, jlong, jlong);
+JNIEXPORT jint JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeGetElem (JNIEnv *env, jobject, jlong, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeSetElem (JNIEnv *env, jobject, jlong, jint, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeDrawSurface (JNIEnv *env, jobject, jlong, jlong, jdoubleArray, jdouble);
+JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeGetPixels (JNIEnv *env, jobject, jlong, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeSetPixels (JNIEnv *env, jobject, jlong, jintArray);
+JNIEXPORT jlong JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_getFlippedBuffer (JNIEnv *env, jobject, jlong, jint);
+JNIEXPORT jlong JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_nativeNewCairoContext (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_CairoSurface_copyAreaNative2 (JNIEnv *env, jobject, jlong, jint, jint, jint, jint, jint, jint, jint);
#ifdef __cplusplus
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_ComponentGraphics_end_1gdk_1drawing (JNIEnv *env, jobject);
JNIEXPORT jboolean JNICALL Java_gnu_java_awt_peer_gtk_ComponentGraphics_hasXRender (JNIEnv *env, jclass);
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_ComponentGraphics_copyAreaNative (JNIEnv *env, jobject, jobject, jint, jint, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_ComponentGraphics_drawVolatile (JNIEnv *env, jobject, jobject, jobject, jint, jint, jint, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_ComponentGraphics_drawVolatile (JNIEnv *env, jobject, jobject, jlong, jint, jint, jint, jint);
#ifdef __cplusplus
}
{
#endif
-JNIEXPORT jint JNICALL Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getGlyph (JNIEnv *env, jobject, jint);
+JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getGlyphs (JNIEnv *env, jobject, jintArray);
JNIEXPORT jobject JNICALL Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getKerning (JNIEnv *env, jobject, jint, jint);
JNIEXPORT jdoubleArray JNICALL Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getMetricsNative (JNIEnv *env, jobject, jint);
JNIEXPORT jobject JNICALL Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getGlyphOutlineNative (JNIEnv *env, jobject, jint);
+++ /dev/null
-/* DO NOT EDIT THIS FILE - it is machine generated */
-
-#ifndef __gnu_java_awt_peer_gtk_GdkGraphics__
-#define __gnu_java_awt_peer_gtk_GdkGraphics__
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_initStaticState (JNIEnv *env, jclass);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_initState__Lgnu_java_awt_peer_gtk_GtkComponentPeer_2 (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_initStateUnlocked (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_initState__II (JNIEnv *env, jobject, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_initFromImage (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_nativeCopyState (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_connectSignals (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_clearRect (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_copyArea (JNIEnv *env, jobject, jint, jint, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_nativeDispose (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawLine (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawArc (JNIEnv *env, jobject, jint, jint, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_fillArc (JNIEnv *env, jobject, jint, jint, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawOval (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_fillOval (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawPolygon (JNIEnv *env, jobject, jintArray, jintArray, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_fillPolygon (JNIEnv *env, jobject, jintArray, jintArray, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawPolyline (JNIEnv *env, jobject, jintArray, jintArray, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawRect (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_fillRect (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_drawString (JNIEnv *env, jobject, jobject, jstring, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_setClipRectangle (JNIEnv *env, jobject, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_setFGColor (JNIEnv *env, jobject, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_setFunction (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_translateNative (JNIEnv *env, jobject, jint, jint);
-#undef gnu_java_awt_peer_gtk_GdkGraphics_GDK_COPY
-#define gnu_java_awt_peer_gtk_GdkGraphics_GDK_COPY 0L
-#undef gnu_java_awt_peer_gtk_GdkGraphics_GDK_XOR
-#define gnu_java_awt_peer_gtk_GdkGraphics_GDK_XOR 2L
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __gnu_java_awt_peer_gtk_GdkGraphics__ */
+++ /dev/null
-/* DO NOT EDIT THIS FILE - it is machine generated */
-
-#ifndef __gnu_java_awt_peer_gtk_GdkGraphics2D__
-#define __gnu_java_awt_peer_gtk_GdkGraphics2D__
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initStaticState (JNIEnv *env, jclass);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initStateUnlocked (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initState__Lgnu_java_awt_peer_gtk_GtkComponentPeer_2 (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initState__II (JNIEnv *env, jobject, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initState___3III (JNIEnv *env, jobject, jintArray, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_copyState (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_dispose (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSurfaceSetFilter (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSurfaceSetFilterUnlocked (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_connectSignals (JNIEnv *env, jobject, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable (JNIEnv *env, jobject, jobject, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_drawPixels (JNIEnv *env, jobject, jintArray, jint, jint, jint, jdoubleArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_setTexturePixelsUnlocked (JNIEnv *env, jobject, jintArray, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_setTexturePixels (JNIEnv *env, jobject, jintArray, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_setGradient (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jint, jint, jint, jint, jint, jint, jint, jint, jboolean);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_setGradientUnlocked (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jint, jint, jint, jint, jint, jint, jint, jint, jboolean);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSave (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRestore (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMatrix (JNIEnv *env, jobject, jdoubleArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMatrixUnlocked (JNIEnv *env, jobject, jdoubleArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetOperator (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetRGBAColor (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetRGBAColorUnlocked (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetFillRule (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineWidth (JNIEnv *env, jobject, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineWidthUnlocked (JNIEnv *env, jobject, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineCap (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineCapUnlocked (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineJoin (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineJoinUnlocked (JNIEnv *env, jobject, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetDash (JNIEnv *env, jobject, jdoubleArray, jint, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetDashUnlocked (JNIEnv *env, jobject, jdoubleArray, jint, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMiterLimit (JNIEnv *env, jobject, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMiterLimitUnlocked (JNIEnv *env, jobject, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoNewPath (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoMoveTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoLineTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoCurveTo (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRelMoveTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRelLineTo (JNIEnv *env, jobject, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRelCurveTo (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoRectangle (JNIEnv *env, jobject, jdouble, jdouble, jdouble, jdouble);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoClosePath (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoStroke (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoFill (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoClip (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoDrawGlyphVector (JNIEnv *env, jobject, jobject, jfloat, jfloat, jint, jintArray, jfloatArray);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoDrawGdkTextLayout (JNIEnv *env, jobject, jobject, jfloat, jfloat);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_releasePeerGraphicsResource (JNIEnv *env, jclass, jobject);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __gnu_java_awt_peer_gtk_GdkGraphics2D__ */
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_indexToPos (JNIEnv *env, jobject, jint, jdoubleArray);
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_initState (JNIEnv *env, jobject);
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_dispose (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_cairoDrawGdkTextLayout (JNIEnv *env, jobject, jobject, jfloat, jfloat);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_cairoDrawGdkTextLayout (JNIEnv *env, jobject, jlong, jfloat, jfloat);
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_initStaticState (JNIEnv *env, jclass);
JNIEXPORT jobject JNICALL Java_gnu_java_awt_peer_gtk_GdkTextLayout_getOutline (JNIEnv *env, jobject, jobject);
#endif
JNIEXPORT jlong JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_init (JNIEnv *env, jobject, jobject, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_destroy (JNIEnv *env, jobject);
-JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_getPixels (JNIEnv *env, jobject);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_copyArea (JNIEnv *env, jobject, jint, jint, jint, jint, jint, jint);
-JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_drawVolatile (JNIEnv *env, jobject, jlong, jint, jint, jint, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_destroy (JNIEnv *env, jobject, jlong);
+JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_nativeGetPixels (JNIEnv *env, jobject, jlong);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_nativeCopyArea (JNIEnv *env, jobject, jlong, jint, jint, jint, jint, jint, jint);
+JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkVolatileImage_nativeDrawVolatile (JNIEnv *env, jobject, jlong, jlong, jint, jint, jint, jint);
#ifdef __cplusplus
}
if (gfx == null && parent != null)
{
gfx = parent.getGraphics();
- Rectangle bounds = getBounds();
- gfx.setClip(bounds);
- gfx.translate(bounds.x, bounds.y);
+ gfx.clipRect(getX(), getY(), getWidth(), getHeight());
+ gfx.translate(getX(), getY());
return gfx;
}
gfx.setFont(font);
package java.awt.datatransfer;
+import gnu.classpath.NotImplementedException;
+
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
*
* @exception IOException If an error occurs.
*/
- public void writeExternal(ObjectOutput stream) throws IOException
+ public void writeExternal(ObjectOutput stream)
+ throws IOException, NotImplementedException
{
// FIXME: Implement me
}
* cannot be found.
*/
public void readExternal(ObjectInput stream)
- throws IOException, ClassNotFoundException
+ throws IOException, ClassNotFoundException, NotImplementedException
{
// FIXME: Implement me
}
/* DropTargetContext.java --
- Copyright (C) 2002, 2003, 2004 Free Software Foundation
+ Copyright (C) 2002, 2003, 2004, 2006, Free Software Foundation
This file is part of GNU Classpath.
package java.awt.dnd;
+import gnu.classpath.NotImplementedException;
+
import java.awt.Component;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
protected boolean isLocal;
protected Transferable transferable;
- TransferableProxy (Transferable t, boolean local)
+ TransferableProxy(Transferable t, boolean local)
{
this.transferable = t;
this.isLocal = local;
}
- public DataFlavor[] getTransferDataFlavors ()
+ public DataFlavor[] getTransferDataFlavors()
{
- return transferable.getTransferDataFlavors ();
+ return transferable.getTransferDataFlavors();
}
- public boolean isDataFlavorSupported (DataFlavor flavor)
+ public boolean isDataFlavorSupported(DataFlavor flavor)
{
- return transferable.isDataFlavorSupported (flavor);
+ return transferable.isDataFlavorSupported(flavor);
}
- public Object getTransferData (DataFlavor flavor)
+ public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException, IOException
{
return transferable.getTransferData (flavor);
private java.awt.dnd.peer.DropTargetContextPeer dtcp;
// package private
- DropTargetContext (DropTarget dropTarget)
+ DropTargetContext(DropTarget dropTarget)
{
this.dropTarget = dropTarget;
}
- public DropTarget getDropTarget ()
+ public DropTarget getDropTarget()
{
return dropTarget;
}
- public Component getComponent ()
+ public Component getComponent()
{
- return dropTarget.getComponent ();
+ return dropTarget.getComponent();
}
- public void addNotify (java.awt.dnd.peer.DropTargetContextPeer dtcp)
+ public void addNotify(java.awt.dnd.peer.DropTargetContextPeer dtcp)
{
this.dtcp = dtcp;
}
- public void removeNotify ()
+ public void removeNotify()
{
this.dtcp = null;
}
- protected void setTargetActions (int actions)
+ protected void setTargetActions(int actions)
{
targetActions = actions;
}
*
* @exception InvalidDnDOperationException If a drop is not outstanding.
*/
- public void dropComplete (boolean success)
+ public void dropComplete(boolean success)
+ throws NotImplementedException
{
// FIXME: implement this
}
- protected void acceptDrag (int dragOperation)
+ protected void acceptDrag(int dragOperation)
+ throws NotImplementedException
{
// FIXME: implement this
}
- protected void rejectDrag ()
+ protected void rejectDrag()
+ throws NotImplementedException
{
// FIXME: implement this
}
- protected void acceptDrop (int dropOperation)
+ protected void acceptDrop(int dropOperation)
+ throws NotImplementedException
{
// FIXME: implement this
}
- protected void rejectDrop ()
+ protected void rejectDrop()
+ throws NotImplementedException
{
// FIXME: implement this
}
- protected DataFlavor[] getCurrentDataFlavors ()
+ protected DataFlavor[] getCurrentDataFlavors()
+ throws NotImplementedException
{
// FIXME: implement this
return null;
}
- protected List getCurrentDataFlavorsAsList ()
+ protected List getCurrentDataFlavorsAsList()
{
- return Arrays.asList (getCurrentDataFlavors ());
+ return Arrays.asList(getCurrentDataFlavors());
}
- protected boolean isDataFlavorSupported (DataFlavor flavor)
+ protected boolean isDataFlavorSupported(DataFlavor flavor)
{
- return getCurrentDataFlavorsAsList ().contains (flavor);
+ return getCurrentDataFlavorsAsList().contains(flavor);
}
/**
*
* @exception InvalidDnDOperationException If a drag is not outstanding.
*/
- protected Transferable getTransferable() throws InvalidDnDOperationException
+ protected Transferable getTransferable()
+ throws InvalidDnDOperationException, NotImplementedException
{
// FIXME: implement this
return null;
protected Transferable createTransferableProxy(Transferable t, boolean local)
{
- return new TransferableProxy (t, local);
+ return new TransferableProxy(t, local);
}
} // class DropTargetContext
package java.awt.dnd;
+import gnu.classpath.NotImplementedException;
+
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
* actions is not a bitwise mask of DnDConstants, or dtc is null.
* @exception NullPointerException If location is null.
*/
- public DropTargetDropEvent (DropTargetContext dtc, Point location,
- int dropAction, int actions)
+ public DropTargetDropEvent(DropTargetContext dtc, Point location,
+ int dropAction, int actions)
{
- this (dtc, location, dropAction, actions, false);
+ this(dtc, location, dropAction, actions, false);
}
/**
* actions is not a bitwise mask of DnDConstants, or dtc is null.
* @exception NullPointerException If location is null.
*/
- public DropTargetDropEvent (DropTargetContext dtc, Point location,
- int dropAction, int actions, boolean isLocalTx)
+ public DropTargetDropEvent(DropTargetContext dtc, Point location,
+ int dropAction, int actions, boolean isLocalTx)
{
- super (dtc);
+ super(dtc);
if (location == null)
- throw new NullPointerException ();
+ throw new NullPointerException();
if (dtc == null)
- throw new IllegalArgumentException ();
+ throw new IllegalArgumentException();
if (dropAction != DnDConstants.ACTION_NONE
&& dropAction != DnDConstants.ACTION_COPY
&& dropAction != DnDConstants.ACTION_COPY_OR_MOVE
&& dropAction != DnDConstants.ACTION_LINK
&& dropAction != DnDConstants.ACTION_REFERENCE)
- throw new IllegalArgumentException ();
+ throw new IllegalArgumentException();
int actionsMask = DnDConstants.ACTION_NONE
| DnDConstants.ACTION_COPY
| DnDConstants.ACTION_REFERENCE;
if (~(actions ^ actionsMask) != 0)
- throw new IllegalArgumentException ();
+ throw new IllegalArgumentException();
this.dropAction = dropAction;
this.actions = actions;
this.isLocalTx = isLocalTx;
}
- public Point getLocation ()
+ public Point getLocation()
{
return location;
}
- public DataFlavor[] getCurrentDataFlavors ()
+ public DataFlavor[] getCurrentDataFlavors()
{
- return context.getCurrentDataFlavors ();
+ return context.getCurrentDataFlavors();
}
- public List getCurrentDataFlavorsAsList ()
+ public List getCurrentDataFlavorsAsList()
{
- return context.getCurrentDataFlavorsAsList ();
+ return context.getCurrentDataFlavorsAsList();
}
- public boolean isDataFlavorSupported (DataFlavor flavor)
+ public boolean isDataFlavorSupported(DataFlavor flavor)
{
- return context.isDataFlavorSupported (flavor);
+ return context.isDataFlavorSupported(flavor);
}
- public int getSourceActions ()
+ public int getSourceActions()
{
return actions;
}
- public int getDropAction ()
+ public int getDropAction()
{
return dropAction;
}
- public Transferable getTransferable ()
+ public Transferable getTransferable()
{
return context.getTransferable ();
}
- public void acceptDrop (int dropAction)
+ public void acceptDrop(int dropAction)
{
- context.acceptDrop (dropAction);
+ context.acceptDrop(dropAction);
}
- public void rejectDrop ()
+ public void rejectDrop()
{
- context.rejectDrop ();
+ context.rejectDrop();
}
- public void dropComplete (boolean success)
+ public void dropComplete(boolean success)
+ throws NotImplementedException
{
// FIXME: implement this
}
/* LineBreakMeasurer.java
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2006 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.awt.font;
-import gnu.classpath.NotImplementedException;
-
import java.text.AttributedCharacterIterator;
+import java.text.AttributedString;
import java.text.BreakIterator;
+import java.awt.font.TextLayout;
+import java.awt.font.FontRenderContext;
+import java.awt.Shape;
public final class LineBreakMeasurer
{
- private AttributedCharacterIterator ci;
+ private AttributedCharacterIterator text;
+ private int position;
private FontRenderContext frc;
- private BreakIterator bi;
+ private TextLayout totalLayout;
+ private int numChars;
- /**
- * Constructs a <code>LineBreakMeasurer</code> object.
- */
- public LineBreakMeasurer (AttributedCharacterIterator text,
- FontRenderContext frc)
+ public LineBreakMeasurer(AttributedCharacterIterator text,
+ BreakIterator breakIter, FontRenderContext frc)
{
- this (text, null, frc);
+ this.text = text;
+ this.frc = frc;
+ position = 0;
+ totalLayout = new TextLayout(text, frc);
+ numChars = totalLayout.getCharacterCount();
}
- /**
- * Constructs a <code>LineBreakMeasurer</code> object.
- */
- public LineBreakMeasurer (AttributedCharacterIterator text,
- BreakIterator breakIter, FontRenderContext frc)
+ public LineBreakMeasurer(AttributedCharacterIterator text,
+ FontRenderContext frc)
{
- this.ci = text;
- this.bi = breakIter;
+ this.text = text;
this.frc = frc;
+ position = 0;
+ totalLayout = new TextLayout(text, frc);
+ numChars = totalLayout.getCharacterCount();
}
- public void deleteChar (AttributedCharacterIterator newParagraph,
- int deletePos)
- throws NotImplementedException
+ public void deleteChar(AttributedCharacterIterator newParagraph,
+ int deletePos)
{
- throw new Error ("not implemented");
+ totalLayout = new TextLayout(newParagraph, frc);
+ if( deletePos < 0 || deletePos > totalLayout.getCharacterCount() )
+ throw new NullPointerException("Invalid deletePos:"+deletePos);
+ numChars = totalLayout.getCharacterCount();
+ text = newParagraph;
+ position = 0;
}
- public int getPosition ()
+ public void insertChar(AttributedCharacterIterator newParagraph,
+ int insertPos)
{
- return ci.getIndex ();
+ totalLayout = new TextLayout(newParagraph, frc);
+ if( insertPos < 0 || insertPos > totalLayout.getCharacterCount() )
+ throw new NullPointerException("Invalid insertPos:"+insertPos);
+ numChars = totalLayout.getCharacterCount();
+ text = newParagraph;
+ position = 0;
}
- public void insertChar (AttributedCharacterIterator newParagraph,
- int insertPos)
- throws NotImplementedException
+ public TextLayout nextLayout(float wrappingWidth)
{
- throw new Error ("not implemented");
+ return nextLayout( wrappingWidth, numChars, false );
}
- public TextLayout nextLayout (float wrappingWidth)
- throws NotImplementedException
+ public TextLayout nextLayout(float wrappingWidth, int offsetLimit,
+ boolean requireNextWord)
{
- throw new Error ("not implemented");
+ int next = nextOffset( wrappingWidth, offsetLimit, requireNextWord );
+ AttributedCharacterIterator aci = (new AttributedString( text,
+ position, next )
+ ).getIterator();
+ position = next;
+ return new TextLayout( aci, frc );
}
- public TextLayout nextLayout (float wrappingWidth, int offsetLimit,
- boolean requireNextWord)
- throws NotImplementedException
+ public int nextOffset(float wrappingWidth)
{
- throw new Error ("not implemented");
+ return nextOffset( wrappingWidth, numChars, false );
}
- public int nextOffset (float wrappingWidth)
- throws NotImplementedException
+ public int nextOffset(float wrappingWidth, int offsetLimit,
+ boolean requireNextWord)
{
- throw new Error ("not implemented");
+ Shape s = totalLayout.getBlackBoxBounds( position, offsetLimit );
+ double remainingLength = s.getBounds2D().getWidth();
+
+ int guessOffset = (int)( ( (double)wrappingWidth / (double)remainingLength)
+ * ( (double)numChars - (double)position ) );
+ guessOffset += position;
+ if( guessOffset > offsetLimit )
+ guessOffset = offsetLimit;
+
+ s = totalLayout.getBlackBoxBounds( position, guessOffset );
+ double guessLength = s.getBounds2D().getWidth();
+
+ boolean makeSmaller = ( guessLength > wrappingWidth );
+ int inc = makeSmaller ? -1 : 1;
+ boolean keepGoing = true;
+
+ do
+ {
+ guessOffset = guessOffset + inc;
+ if( guessOffset <= position || guessOffset > offsetLimit )
+ {
+ keepGoing = false;
+ }
+ else
+ {
+ s = totalLayout.getBlackBoxBounds( position, guessOffset );
+ guessLength = s.getBounds2D().getWidth();
+ if( makeSmaller && ( guessLength <= wrappingWidth) )
+ keepGoing = false;
+ if( !makeSmaller && ( guessLength >= wrappingWidth) )
+ keepGoing = false;
+ }
+ }
+ while( keepGoing );
+
+ if( !makeSmaller )
+ guessOffset--;
+
+ if( guessOffset >= offsetLimit )
+ return offsetLimit;
+
+ text.setIndex( guessOffset );
+ if( !requireNextWord )
+ {
+ char c = text.previous();
+ while( !Character.isWhitespace( c ) && c != '-' &&
+ guessOffset > position )
+ {
+ guessOffset--;
+ c = text.previous();
+ }
+ }
+ else
+ {
+ char c = text.next();
+ while( !Character.isWhitespace( c ) && c != '-' &&
+ guessOffset < offsetLimit )
+ {
+ guessOffset++;
+ c = text.next();
+ }
+ }
+
+ return guessOffset;
}
- public int nextOffset (float wrappingWidth, int offsetLimit,
- boolean requireNextWord)
- throws NotImplementedException
+ public void setPosition(int newPosition)
{
- throw new Error ("not implemented");
+ position = newPosition;
}
- public void setPosition (int newPosition)
+ public int getPosition()
{
- ci.setIndex (newPosition);
+ return position;
}
}
+
/* TextLayout.java --
- Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2006 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.awt.font;
-import gnu.java.awt.ClasspathToolkit;
-import gnu.java.awt.peer.ClasspathTextLayoutPeer;
+import gnu.classpath.NotImplementedException;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
import java.text.AttributedCharacterIterator;
import java.text.AttributedString;
+import java.text.Bidi;
import java.util.Map;
/**
- * @author Michael Koch
+ * @author Sven de Marothy
*/
public final class TextLayout implements Cloneable
{
- public static final CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy ();
- ClasspathTextLayoutPeer peer;
-
- public static class CaretPolicy
+ private GlyphVector[] runs;
+ private Font font;
+ private FontRenderContext frc;
+ private String string;
+ private Rectangle2D boundsCache;
+ private LineMetrics lm;
+
+ /**
+ * Start and end character indices of the runs.
+ * First index is the run number, second is 0 or 1 for the starting
+ * and ending character index of the run, respectively.
+ */
+ private int[][] runIndices;
+
+ /**
+ * Base directionality, determined from the first char.
+ */
+ private boolean leftToRight;
+
+ /**
+ * Whether this layout contains whitespace or not.
+ */
+ private boolean hasWhitespace = false;
+
+ /**
+ * The default caret policy.
+ */
+ static TextLayout.CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy();
+
+ /**
+ * Constructs a TextLayout.
+ */
+ public TextLayout (String string, Font font, FontRenderContext frc)
{
- public CaretPolicy ()
- {
- // Do nothing here.
- }
+ this.font = font;
+ this.frc = frc;
+ this.string = string;
+ lm = font.getLineMetrics(string, frc);
- public TextHitInfo getStrongCaret (TextHitInfo hit1, TextHitInfo hit2,
- TextLayout layout)
- {
- return layout.peer.getStrongCaret(hit1, hit2);
- }
- }
+ // Get base direction and whitespace info
+ getStringProperties();
- public TextLayout (AttributedCharacterIterator text, FontRenderContext frc)
- {
- AttributedString as = new AttributedString (text);
- ClasspathToolkit tk = (ClasspathToolkit)(Toolkit.getDefaultToolkit ());
- peer = tk.getClasspathTextLayoutPeer(as, frc);
+ if( Bidi.requiresBidi( string.toCharArray(), 0, string.length() ) )
+ {
+ Bidi bidi = new Bidi( string, leftToRight ?
+ Bidi.DIRECTION_LEFT_TO_RIGHT :
+ Bidi.DIRECTION_RIGHT_TO_LEFT );
+ int rc = bidi.getRunCount();
+ byte[] table = new byte[ rc ];
+ for(int i = 0; i < table.length; i++)
+ table[i] = (byte)bidi.getRunLevel(i);
+
+ runs = new GlyphVector[ rc ];
+ runIndices = new int[rc][2];
+ for(int i = 0; i < runs.length; i++)
+ {
+ runIndices[i][0] = bidi.getRunStart( i );
+ runIndices[i][1] = bidi.getRunLimit( i );
+ if( runIndices[i][0] != runIndices[i][1] ) // no empty runs.
+ {
+ runs[i] = font.layoutGlyphVector
+ ( frc, string.toCharArray(),
+ runIndices[i][0], runIndices[i][1],
+ ((table[i] & 1) == 0) ? Font.LAYOUT_LEFT_TO_RIGHT :
+ Font.LAYOUT_RIGHT_TO_LEFT );
+ }
+ }
+ Bidi.reorderVisually( table, 0, runs, 0, runs.length );
+ }
+ else
+ {
+ runs = new GlyphVector[ 1 ];
+ runIndices = new int[1][2];
+ runIndices[0][0] = 0;
+ runIndices[0][1] = string.length();
+ runs[ 0 ] = font.layoutGlyphVector( frc, string.toCharArray(),
+ 0, string.length(),
+ leftToRight ?
+ Font.LAYOUT_LEFT_TO_RIGHT :
+ Font.LAYOUT_RIGHT_TO_LEFT );
+ }
}
- public TextLayout (String string, Font font, FontRenderContext frc)
+ public TextLayout (String string, Map attributes, FontRenderContext frc)
{
- AttributedString as = new AttributedString (string);
- as.addAttribute (TextAttribute.FONT, font);
- ClasspathToolkit tk = (ClasspathToolkit)(Toolkit.getDefaultToolkit ());
- peer = tk.getClasspathTextLayoutPeer(as, frc);
+ this( string, new Font( attributes ), frc );
}
- public TextLayout (String string, Map attributes, FontRenderContext frc)
- {
- AttributedString as = new AttributedString (string, attributes);
- ClasspathToolkit tk = (ClasspathToolkit)(Toolkit.getDefaultToolkit ());
- peer = tk.getClasspathTextLayoutPeer(as, frc);
+ public TextLayout (AttributedCharacterIterator text, FontRenderContext frc)
+ throws NotImplementedException
+ {
+ throw new Error ("not implemented");
+ }
+
+ /**
+ * Scan the character run for the first strongly directional character,
+ * which in turn defines the base directionality of the whole layout.
+ */
+ private void getStringProperties()
+ {
+ boolean gotDirection = false;
+ int i = 0;
+
+ leftToRight = true;
+ while( i < string.length() && !gotDirection )
+ switch( Character.getDirectionality( string.charAt( i++ ) ) )
+ {
+ case Character.DIRECTIONALITY_LEFT_TO_RIGHT:
+ case Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING:
+ case Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE:
+ gotDirection = true;
+ break;
+
+ case Character.DIRECTIONALITY_RIGHT_TO_LEFT:
+ case Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC:
+ case Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING:
+ case Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE:
+ leftToRight = false;
+ gotDirection = true;
+ break;
+ }
+
+ // Determine if there's whitespace in the thing.
+ // Ignore trailing chars.
+ i = string.length() - 1;
+ hasWhitespace = false;
+ while( i >= 0 && Character.isWhitespace( string.charAt(i) ) )
+ i--;
+ // Check the remaining chars
+ while( i >= 0 )
+ if( Character.isWhitespace( string.charAt(i--) ) )
+ hasWhitespace = true;
}
protected Object clone ()
{
- try
- {
- TextLayout tl = (TextLayout) super.clone ();
- tl.peer = (ClasspathTextLayoutPeer) this.peer.clone();
- return tl;
- }
- catch (CloneNotSupportedException e)
- {
- // This should never occur
- throw new InternalError ();
- }
+ return new TextLayout( string, font, frc );
}
-
public void draw (Graphics2D g2, float x, float y)
- {
- peer.draw(g2, x, y);
+ {
+ for(int i = 0; i < runs.length; i++)
+ {
+ g2.drawGlyphVector(runs[i], x, y);
+ Rectangle2D r = runs[i].getLogicalBounds();
+ x += r.getWidth();
+ }
}
public boolean equals (Object obj)
{
- if (! (obj instanceof TextLayout))
+ if( !( obj instanceof TextLayout) )
return false;
- return equals ((TextLayout) obj);
+ return equals( (TextLayout) obj );
}
public boolean equals (TextLayout tl)
{
- return this.peer.equals(tl.peer);
+ if( runs.length != tl.runs.length )
+ return false;
+ // Compare all glyph vectors.
+ for( int i = 0; i < runs.length; i++ )
+ if( !runs[i].equals( tl.runs[i] ) )
+ return false;
+ return true;
}
public float getAdvance ()
{
- return peer.getAdvance();
+ float totalAdvance = 0f;
+ for(int i = 0; i < runs.length; i++)
+ totalAdvance += runs[i].getLogicalBounds().getWidth();
+ return totalAdvance;
}
public float getAscent ()
{
- return peer.getAscent();
+ return lm.getAscent();
}
public byte getBaseline ()
{
- return peer.getBaseline();
+ return (byte)lm.getBaselineIndex();
}
public float[] getBaselineOffsets ()
{
- return peer.getBaselineOffsets();
+ return lm.getBaselineOffsets();
}
public Shape getBlackBoxBounds (int firstEndpoint, int secondEndpoint)
{
- return peer.getBlackBoxBounds(firstEndpoint, secondEndpoint);
+ if( firstEndpoint < 0 || secondEndpoint > getCharacterCount() )
+ return new Rectangle2D.Float();
+
+ GeneralPath gp = new GeneralPath();
+ int i = 0; // run index
+ double advance = 0;
+
+ // go to first run
+ while( runIndices[i + 1][1] < firstEndpoint )
+ {
+ advance += runs[i].getLogicalBounds().getWidth();
+ i++;
+ }
+
+ int j = 0; // index into the run.
+ if( runIndices[i][1] - runIndices[i][0] > 1 )
+ {
+ while( runs[i].getGlyphCharIndex( j + 1 ) <
+ (firstEndpoint - runIndices[i][0] ) )j++;
+ }
+
+ gp.append(runs[i].getGlyphVisualBounds( j ), false);
+ boolean keepGoing = true;;
+
+ do
+ {
+ while( j < runs[i].getNumGlyphs() &&
+ runs[i].getGlyphCharIndex( j ) + runIndices[i][0] <
+ secondEndpoint )
+ {
+ Rectangle2D r2 = (runs[i].getGlyphVisualBounds( j )).
+ getBounds2D();
+ Point2D p = runs[i].getGlyphPosition( j );
+ r2.setRect( advance + p.getX(), r2.getY(),
+ r2.getWidth(), r2.getHeight() );
+ gp.append(r2, false);
+ j++;
+ }
+
+ if( j >= runs[i].getNumGlyphs() )
+ {
+ advance += runs[i].getLogicalBounds().getWidth();
+ i++;
+ j = 0;
+ }
+ else
+ keepGoing = false;
+ }
+ while( keepGoing );
+
+ return gp;
}
public Rectangle2D getBounds()
{
- return peer.getBounds();
+ if( boundsCache == null )
+ boundsCache = getOutline(new AffineTransform()).getBounds();
+ return boundsCache;
}
public float[] getCaretInfo (TextHitInfo hit)
}
public float[] getCaretInfo (TextHitInfo hit, Rectangle2D bounds)
+ throws NotImplementedException
{
- return peer.getCaretInfo(hit, bounds);
+ throw new Error ("not implemented");
}
public Shape getCaretShape (TextHitInfo hit)
{
- return getCaretShape(hit, getBounds());
+ return getCaretShape( hit, getBounds() );
}
public Shape getCaretShape (TextHitInfo hit, Rectangle2D bounds)
+ throws NotImplementedException
{
- return peer.getCaretShape(hit, bounds);
+ throw new Error ("not implemented");
}
public Shape[] getCaretShapes (int offset)
{
- return getCaretShapes(offset, getBounds());
+ return getCaretShapes( offset, getBounds() );
}
public Shape[] getCaretShapes (int offset, Rectangle2D bounds)
+ throws NotImplementedException
{
- return getCaretShapes(offset, getBounds(), DEFAULT_CARET_POLICY);
- }
-
- public Shape[] getCaretShapes (int offset, Rectangle2D bounds,
- TextLayout.CaretPolicy policy)
- {
- return peer.getCaretShapes(offset, bounds, policy);
+ throw new Error ("not implemented");
}
public int getCharacterCount ()
{
- return peer.getCharacterCount();
+ return string.length();
}
public byte getCharacterLevel (int index)
+ throws NotImplementedException
{
- return peer.getCharacterLevel(index);
+ throw new Error ("not implemented");
}
public float getDescent ()
{
- return peer.getDescent();
+ return lm.getDescent();
}
public TextLayout getJustifiedLayout (float justificationWidth)
{
- return peer.getJustifiedLayout(justificationWidth);
+ TextLayout newLayout = (TextLayout)clone();
+
+ if( hasWhitespace )
+ newLayout.handleJustify( justificationWidth );
+
+ return newLayout;
}
public float getLeading ()
{
- return peer.getLeading();
+ return lm.getLeading();
}
public Shape getLogicalHighlightShape (int firstEndpoint, int secondEndpoint)
{
- return getLogicalHighlightShape (firstEndpoint, secondEndpoint, getBounds());
+ return getLogicalHighlightShape( firstEndpoint, secondEndpoint,
+ getBounds() );
}
public Shape getLogicalHighlightShape (int firstEndpoint, int secondEndpoint,
Rectangle2D bounds)
{
- return peer.getLogicalHighlightShape(firstEndpoint, secondEndpoint, bounds);
+ if( firstEndpoint < 0 || secondEndpoint > getCharacterCount() )
+ return new Rectangle2D.Float();
+
+ int i = 0; // run index
+ double advance = 0;
+
+ // go to first run
+ if( i > 0 )
+ while( runIndices[i + 1][1] < firstEndpoint )
+ {
+ advance += runs[i].getLogicalBounds().getWidth();
+ i++;
+ }
+
+ int j = 0; // index into the run.
+ if( runIndices[i][1] - runIndices[i][0] > 1 )
+ {
+ while( runs[i].getGlyphCharIndex( j + 1 ) <
+ (firstEndpoint - runIndices[i][0] ) )j++;
+ }
+
+ Rectangle2D r = (runs[i].getGlyphLogicalBounds( j )).getBounds2D();
+ boolean keepGoing = true;;
+
+ do
+ {
+ while( j < runs[i].getNumGlyphs() &&
+ runs[i].getGlyphCharIndex( j ) + runIndices[i][0] <
+ secondEndpoint )
+ {
+ Rectangle2D r2 = (runs[i].getGlyphLogicalBounds( j )).
+ getBounds2D();
+ Point2D p = runs[i].getGlyphPosition( j );
+ r2.setRect( advance + p.getX(), r2.getY(),
+ r2.getWidth(), r2.getHeight() );
+ r = r.createUnion( r2 );
+ j++;
+ }
+
+ if( j >= runs[i].getNumGlyphs() )
+ {
+ advance += runs[i].getLogicalBounds().getWidth();
+ i++;
+ j = 0;
+ }
+ else
+ keepGoing = false;
+ }
+ while( keepGoing );
+
+ return r;
}
public int[] getLogicalRangesForVisualSelection (TextHitInfo firstEndpoint,
TextHitInfo secondEndpoint)
+ throws NotImplementedException
{
- return peer.getLogicalRangesForVisualSelection(firstEndpoint, secondEndpoint);
+ throw new Error ("not implemented");
}
public TextHitInfo getNextLeftHit (int offset)
+ throws NotImplementedException
{
- return getNextLeftHit(offset, DEFAULT_CARET_POLICY);
- }
-
- public TextHitInfo getNextLeftHit (int offset, TextLayout.CaretPolicy policy)
- {
- return peer.getNextLeftHit(offset, policy);
+ throw new Error ("not implemented");
}
public TextHitInfo getNextLeftHit (TextHitInfo hit)
+ throws NotImplementedException
{
- return getNextLeftHit(hit.getCharIndex());
+ throw new Error ("not implemented");
}
public TextHitInfo getNextRightHit (int offset)
+ throws NotImplementedException
{
- return getNextRightHit(offset, DEFAULT_CARET_POLICY);
- }
-
- public TextHitInfo getNextRightHit (int offset, TextLayout.CaretPolicy policy)
- {
- return peer.getNextRightHit(offset, policy);
+ throw new Error ("not implemented");
}
public TextHitInfo getNextRightHit (TextHitInfo hit)
+ throws NotImplementedException
{
- return getNextRightHit(hit.getCharIndex());
+ throw new Error ("not implemented");
}
public Shape getOutline (AffineTransform tx)
{
- return peer.getOutline(tx);
+ float x = 0f;
+ GeneralPath gp = new GeneralPath();
+ for(int i = 0; i < runs.length; i++)
+ {
+ gp.append( runs[i].getOutline( x, 0f ), false );
+ Rectangle2D r = runs[i].getLogicalBounds();
+ x += r.getWidth();
+ }
+ if( tx != null )
+ gp.transform( tx );
+ return gp;
}
public float getVisibleAdvance ()
{
- return peer.getVisibleAdvance();
+ float totalAdvance = 0f;
+
+ if( runs.length <= 0 )
+ return 0f;
+
+ // No trailing whitespace
+ if( !Character.isWhitespace( string.charAt( string.length() -1 ) ) )
+ return getAdvance();
+
+ // Get length of all runs up to the last
+ for(int i = 0; i < runs.length - 1; i++)
+ totalAdvance += runs[i].getLogicalBounds().getWidth();
+
+ int lastRun = runIndices[ runs.length - 1 ][0];
+ int j = string.length() - 1;
+ while( j >= lastRun && Character.isWhitespace( string.charAt( j ) ) ) j--;
+
+ if( j < lastRun )
+ return totalAdvance; // entire last run is whitespace
+
+ int lastNonWSChar = j - lastRun;
+ j = 0;
+ while( runs[ runs.length - 1 ].getGlyphCharIndex( j )
+ <= lastNonWSChar )
+ {
+ totalAdvance += runs[ runs.length - 1 ].getGlyphLogicalBounds( j ).
+ getBounds2D().getWidth();
+ j ++;
+ }
+
+ return totalAdvance;
}
public Shape getVisualHighlightShape (TextHitInfo firstEndpoint,
TextHitInfo secondEndpoint)
{
- return getVisualHighlightShape(firstEndpoint, secondEndpoint, getBounds());
+ return getVisualHighlightShape( firstEndpoint, secondEndpoint,
+ getBounds() );
}
public Shape getVisualHighlightShape (TextHitInfo firstEndpoint,
TextHitInfo secondEndpoint,
Rectangle2D bounds)
+ throws NotImplementedException
{
- return peer.getVisualHighlightShape(firstEndpoint, secondEndpoint, bounds);
+ throw new Error ("not implemented");
}
public TextHitInfo getVisualOtherHit (TextHitInfo hit)
+ throws NotImplementedException
{
- return peer.getVisualOtherHit(hit);
+ throw new Error ("not implemented");
}
+ /**
+ * This is a protected method of a <code>final</code> class, meaning
+ * it exists only to taunt you.
+ */
protected void handleJustify (float justificationWidth)
{
- peer.handleJustify(justificationWidth);
- }
-
- public int hashCode ()
- {
- return peer.hashCode();
+ // We assume that the text has non-trailing whitespace.
+ // First get the change in width to insert into the whitespaces.
+ double deltaW = justificationWidth - getVisibleAdvance();
+ int nglyphs = 0; // # of whitespace chars
+
+ // determine last non-whitespace char.
+ int lastNWS = string.length() - 1;
+ while( Character.isWhitespace( string.charAt( lastNWS ) ) ) lastNWS--;
+
+ // locations of the glyphs.
+ int[] wsglyphs = new int[string.length() * 10];
+ for(int run = 0; run < runs.length; run++ )
+ for(int i = 0; i < runs[run].getNumGlyphs(); i++ )
+ {
+ int cindex = runIndices[run][0] + runs[run].getGlyphCharIndex( i );
+ if( Character.isWhitespace( string.charAt( cindex ) ) )
+ // && cindex < lastNWS )
+ {
+ wsglyphs[ nglyphs * 2 ] = run;
+ wsglyphs[ nglyphs * 2 + 1] = i;
+ nglyphs++;
+ }
+ }
+
+ deltaW = deltaW / nglyphs; // Change in width per whitespace glyph
+ double w = 0;
+ int cws = 0;
+ // Shift all characters
+ for(int run = 0; run < runs.length; run++ )
+ for(int i = 0; i < runs[ run ].getNumGlyphs(); i++ )
+ {
+ if( wsglyphs[ cws * 2 ] == run && wsglyphs[ cws * 2 + 1 ] == i )
+ {
+ cws++; // update 'current whitespace'
+ w += deltaW; // increment the shift
+ }
+ Point2D p = runs[ run ].getGlyphPosition( i );
+ p.setLocation( p.getX() + w, p.getY() );
+ runs[ run ].setGlyphPosition( i, p );
+ }
}
public TextHitInfo hitTestChar (float x, float y)
public TextHitInfo hitTestChar (float x, float y, Rectangle2D bounds)
{
- return peer.hitTestChar(x, y, bounds);
+ return hitTestChar( x, y, getBounds() );
}
public boolean isLeftToRight ()
{
- return peer.isLeftToRight();
+ return leftToRight;
}
public boolean isVertical ()
{
- return peer.isVertical();
+ return false; // FIXME: How do you create a vertical layout?
+ }
+
+ public int hashCode ()
+ throws NotImplementedException
+ {
+ throw new Error ("not implemented");
}
public String toString ()
{
- return peer.toString();
+ return "TextLayout [string:"+string+", Font:"+font+" Rendercontext:"+
+ frc+"]";
+ }
+
+ /**
+ * Inner class describing a caret policy
+ */
+ public static class CaretPolicy
+ {
+ public CaretPolicy()
+ {
+ }
+
+ public TextHitInfo getStrongCaret(TextHitInfo hit1,
+ TextHitInfo hit2,
+ TextLayout layout)
+ throws NotImplementedException
+ {
+ throw new Error ("not implemented");
+ }
}
}
+
+
public static AffineTransform getTranslateInstance(double tx, double ty)
{
AffineTransform t = new AffineTransform();
- t.setToTranslation(tx, ty);
+ t.m02 = tx;
+ t.m12 = ty;
+ t.type = (tx == 0 && ty == 0) ? TYPE_UNIFORM_SCALE : TYPE_TRANSLATION;
return t;
}
/* BufferedImage.java --
- Copyright (C) 2000, 2002, 2003, 2004, 2005 Free Software Foundation
+ Copyright (C) 2000, 2002, 2003, 2004, 2005, 2006, Free Software Foundation
This file is part of GNU Classpath.
Vector observers;
+ /**
+ * Creates a new buffered image.
+ *
+ * @param w the width.
+ * @param h the height.
+ * @param type the image type (see the constants defined by this class).
+ */
public BufferedImage(int w, int h, int type)
{
ColorModel cm = null;
return 1;
}
+ /**
+ * Returns the value of the specified property, or
+ * {@link Image#UndefinedProperty} if the property is not defined.
+ *
+ * @param string the property key (<code>null</code> not permitted).
+ *
+ * @return The property value.
+ *
+ * @throws NullPointerException if <code>string</code> is <code>null</code>.
+ */
public Object getProperty(String string)
{
- if (properties == null)
- return null;
- return properties.get(string);
+ if (string == null)
+ throw new NullPointerException("The property name cannot be null.");
+ Object result = Image.UndefinedProperty;
+ if (properties != null)
+ {
+ Object v = properties.get(string);
+ if (v != null)
+ result = v;
+ }
+ return result;
}
public Object getProperty(String string, ImageObserver imageobserver)
return getProperty(string);
}
-
+ /**
+ * Returns <code>null</code> always.
+ *
+ * @return <code>null</code> always.
+ */
public String[] getPropertyNames()
{
- // FIXME: implement
+ // This method should always return null, see:
+ // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4640609
return null;
}
* in the grab rectangle will be stored at
* <code>pix[(n - y) * scansize + (m - x) + off]</code>.
*
- * @param ip the ImageProducer from which to grab pixels
+ * @param ip the ImageProducer from which to grab pixels. This can
+ * be null.
* @param x the x coordinate of the grab rectangle's top-left pixel,
* specified relative to the top-left corner of the image produced
* by <code>ip</code>
public PixelGrabber(ImageProducer ip, int x, int y, int w, int h,
int pix[], int off, int scansize)
{
- if (ip == null)
- throw new NullPointerException("The ImageProducer must not be null.");
-
this.ip = ip;
this.x = x;
this.y = y;
}
catch (Exception ex)
{
- ex.printStackTrace();
imageComplete(ImageConsumer.IMAGEABORTED);
}
}
case Character.DIRECTIONALITY_OTHER_NEUTRALS:
case Character.DIRECTIONALITY_SEGMENT_SEPARATOR:
case Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR:
+ case Character.DIRECTIONALITY_WHITESPACE:
if (neutralStart == -1)
neutralStart = i;
break;
? prevStrong
: embeddingDirection);
for (int j = neutralStart; j < i; ++j)
- types[i] = override;
+ types[j] = override;
}
prevStrong = newStrong;
neutralStart = -1;
continue;
boolean translated = false;
- try
- {
- g.clipRect(bounds.x, bounds.y, bounds.width, bounds.height);
- g.translate(bounds.x, bounds.y);
- translated = true;
- children[i].paint(g);
- }
- finally
- {
- if (translated)
- g.translate(-bounds.x, -bounds.y);
- g.setClip(oldClip);
- }
+ Graphics g2 = g.create(bounds.x, bounds.y, bounds.width,
+ bounds.height);
+ children[i].paint(g2);
+ g2.dispose();
}
g.setClip(originalClip);
}
// Paint on the offscreen buffer.
Component root = getRoot(this);
- Image buffer = rm.getOffscreenBuffer(this, root.getWidth(),
- root.getHeight());
+ Image buffer = rm.getVolatileOffscreenBuffer(this, root.getWidth(),
+ root.getHeight());
+
+ // The volatile offscreen buffer may be null when that's not supported
+ // by the AWT backend. Fall back to normal backbuffer in this case.
+ if (buffer == null)
+ buffer = rm.getOffscreenBuffer(this, root.getWidth(), root.getHeight());
+
//Rectangle targetClip = SwingUtilities.convertRectangle(this, r, root);
Point translation = SwingUtilities.convertPoint(this, 0, 0, root);
Graphics g2 = buffer.getGraphics();
- g2.translate(translation.x, translation.y);
- g2.setClip(r.x, r.y, r.width, r.height);
+ clipAndTranslateGraphics(root, this, g2);
+ g2.clipRect(r.x, r.y, r.width, r.height);
g2 = getComponentGraphics(g2);
isPaintingDoubleBuffered = true;
try
}
/**
+ * Clips and translates the Graphics instance for painting on the double
+ * buffer. This has to be done, so that it reflects the component clip of the
+ * target component.
+ *
+ * @param root the root component (top-level container usually)
+ * @param target the component to be painted
+ * @param g the Graphics instance
+ */
+ private void clipAndTranslateGraphics(Component root, Component target,
+ Graphics g)
+ {
+ Component parent = target.getParent();
+ if (parent != root)
+ clipAndTranslateGraphics(root, parent, g);
+
+ g.translate(target.getX(), target.getY());
+ g.clipRect(0, 0, target.getWidth(), target.getHeight());
+ }
+
+ /**
* Performs normal painting without double buffering.
*
* @param r the area that should be repainted
checkIndex(index, -1, tabs.size());
if (index != getSelectedIndex())
{
- if (getSelectedIndex() != -1 && getSelectedComponent() != null)
- getSelectedComponent().hide();
- if (index != -1 && getComponentAt(index) != null)
- getComponentAt(index).show();
model.setSelectedIndex(index);
}
}
public Image getVolatileOffscreenBuffer(Component comp, int proposedWidth,
int proposedHeight)
{
- int maxWidth = doubleBufferMaximumSize.width;
- int maxHeight = doubleBufferMaximumSize.height;
- return comp.createVolatileImage(Math.min(maxWidth, proposedWidth),
- Math.min(maxHeight, proposedHeight));
+ Component root = getRoot(comp);
+ Image buffer = (Image) offscreenBuffers.get(root);
+ if (buffer == null
+ || buffer.getWidth(null) < proposedWidth
+ || buffer.getHeight(null) < proposedHeight
+ || !(buffer instanceof VolatileImage))
+ {
+ int width = Math.max(proposedWidth, root.getWidth());
+ width = Math.min(doubleBufferMaximumSize.width, width);
+ int height = Math.max(proposedHeight, root.getHeight());
+ height = Math.min(doubleBufferMaximumSize.height, height);
+ buffer = root.createVolatileImage(width, height);
+ if (buffer != null)
+ offscreenBuffers.put(root, buffer);
+ }
+ return buffer;
}
this.shadow = shadow;
this.darkShadow = darkShadow;
this.highlight = highlight;
+ // Mark the button as not closing the popup, we handle this ourselves.
+ putClientProperty(BasicLookAndFeel.DONT_CANCEL_POPUP, Boolean.TRUE);
}
/**
*
* @return A new instance of <code>BasicCheckBoxUI</code>.
*/
- public static ComponentUI createUI(JComponent c) {
+ public static ComponentUI createUI(JComponent c)
+ {
return new BasicCheckBoxUI();
}
/**
* Returns preferredSize of the renderer
- *
+ *
* @return preferredSize of the renderer
*/
public Dimension getPreferredSize()
{
- return super.getPreferredSize();
+ if (this.getText() != null && ! this.getText().equals(""))
+ return super.getPreferredSize();
+ else
+ {
+ // If the combo box option's text is empty or null, it won't size
+ // properly (ie, it'll be way too short)... so we throw in a dummy
+ // space to trick the superclass's sizing methods.
+ String oldText = this.getText();
+ this.setText(" ");
+ Dimension d = super.getPreferredSize();
+ this.setText(oldText);
+ return d;
+ }
}
/**
Object prototype = comboBox.getPrototypeDisplayValue();
if (prototype != null)
{
- Component comp = renderer.getListCellRendererComponent
- (listBox, prototype, -1, false, false);
+ Component comp = renderer.getListCellRendererComponent(listBox,
+ prototype, -1, false, false);
currentValuePane.add(comp);
comp.setFont(comboBox.getFont());
Dimension renderSize = comp.getPreferredSize();
{
for (int i = 0; i < size; ++i)
{
- Component comp = renderer.getListCellRendererComponent
- (listBox, model.getElementAt(i), -1, false, false);
+ Component comp = renderer.getListCellRendererComponent(listBox,
+ model.getElementAt(i), -1, false, false);
currentValuePane.add(comp);
comp.setFont(comboBox.getFont());
Dimension renderSize = comp.getPreferredSize();
{
Point point = SwingUtilities.convertPoint((Component) e.getSource(),
e.getPoint(), list);
- MouseEvent newEvent= new MouseEvent((Component) e.getSource(),
+ MouseEvent newEvent = new MouseEvent((Component) e.getSource(),
e.getID(), e.getWhen(),
e.getModifiers(), point.x, point.y,
e.getModifiers(),
String fileDescText;
/** Is a directory selected? */
- boolean dirSelected = false;
+ boolean dirSelected;
/** The current directory. */
- File currDir = null;
+ File currDir;
// FIXME: describe what is contained in the bottom panel
/** The bottom panel. */
protected final int RESIZE_NONE = 0;
/** The x offset from the top left corner of the JInternalFrame. */
- private transient int xOffset = 0;
+ private transient int xOffset;
/** The y offset from the top left corner of the JInternalFrame. */
- private transient int yOffset = 0;
+ private transient int yOffset;
/** The direction that the resize is occuring in. */
private transient int direction = -1;
frame.setCursor(Cursor.getDefaultCursor());
showingCursor = Cursor.DEFAULT_CURSOR;
}
- else if (e.getSource()==frame && frame.isResizable())
+ else if (e.getSource() == frame && frame.isResizable())
{
setCursor(e);
}
import javax.swing.plaf.InsetsUIResource;
/**
- * BasicLookAndFeel
+ * A basic implementation of Swing's Look and Feel framework. This can serve
+ * as a base for custom look and feel implementations.
+ *
* @author Andrew Selkirk
*/
public abstract class BasicLookAndFeel extends LookAndFeel
Component target = ev.getComponent();
if (target instanceof Container)
target = ((Container) target).findComponentAt(ev.getPoint());
- if (! m.isComponentPartOfCurrentMenu(target))
- m.clearSelectedPath();
+ if (m.getSelectedPath().length > 0
+ && ! m.isComponentPartOfCurrentMenu(target))
+ {
+ m.clearSelectedPath();
+ }
}
}
static final long serialVersionUID = -6096995660290287879L;
/**
+ * This is a key for a client property that tells the PopupHelper that
+ * it shouldn't close popups when the mouse event target has this
+ * property set. This is used when the component handles popup closing
+ * itself.
+ */
+ static final String DONT_CANCEL_POPUP = "noCancelPopup";
+
+ /**
* Helps closing menu popups when user clicks outside of the menu area.
*/
private transient PopupHelper popupHelper;
+ /**
+ * Maps the audio actions for this l&f.
+ */
private ActionMap audioActionMap;
/**
}
/**
- * loadResourceBundle
- * @param defaults TODO
+ * Loads the resource bundle in 'resources/basic' and adds the contained
+ * key/value pairs to the <code>defaults</code> table.
+ *
+ * @param defaults the UI defaults to load the resources into
*/
+ // FIXME: This method is not used atm and private and thus could be removed.
+ // However, I consider this method useful for providing localized
+ // descriptions and similar stuff and therefore think that we should use it
+ // instead and provide the resource bundles.
private void loadResourceBundle(UIDefaults defaults)
{
ResourceBundle bundle;
}
/**
- * initComponentDefaults
+ * Populates the <code>defaults</code> table with UI default values for
+ * colors, fonts, keybindings and much more.
+ *
* @param defaults the defaults table (<code>null</code> not permitted).
*/
protected void initComponentDefaults(UIDefaults defaults)
return BasicIconFactory.getMenuItemCheckIcon();
}
},
- "CheckBox.margin",new InsetsUIResource(2, 2, 2, 2),
+ "CheckBox.margin", new InsetsUIResource(2, 2, 2, 2),
"CheckBox.textIconGap", new Integer(4),
"CheckBox.textShiftOffset", new Integer(0),
"CheckBoxMenuItem.acceleratorFont", new FontUIResource("Dialog",
"ctrl F4", "close",
"KP_DOWN", "down",
"ctrl F10", "maximize",
- "ctrl alt shift F6","selectPreviousFrame"
+ "ctrl alt shift F6", "selectPreviousFrame"
}),
"DesktopIcon.border", new BorderUIResource.CompoundBorderUIResource(null,
null),
"PAGE_DOWN", "positiveBlockIncrement",
"END", "maxScroll",
"HOME", "minScroll",
- "LEFT", "positiveUnitIncrement",
+ "LEFT", "negativeUnitIncrement",
"KP_UP", "negativeUnitIncrement",
"KP_DOWN", "positiveUnitIncrement",
"UP", "negativeUnitIncrement",
- "RIGHT", "negativeUnitIncrement",
- "KP_LEFT", "positiveUnitIncrement",
+ "RIGHT", "positiveUnitIncrement",
+ "KP_LEFT", "negativeUnitIncrement",
"DOWN", "positiveUnitIncrement",
- "KP_RIGHT", "negativeUnitIncrement"
+ "KP_RIGHT", "positiveUnitIncrement"
}),
"ScrollBar.foreground", new ColorUIResource(light),
"ScrollBar.maximumThumbSize", new DimensionUIResource(4096, 4096),
"ScrollPane.ancestorInputMap", new UIDefaults.LazyInputMap(new Object[] {
"PAGE_UP", "scrollUp",
"KP_LEFT", "unitScrollLeft",
- "ctrl PAGE_DOWN","scrollRight",
+ "ctrl PAGE_DOWN", "scrollRight",
"PAGE_DOWN", "scrollDown",
"KP_RIGHT", "unitScrollRight",
"LEFT", "unitScrollLeft",
"SplitPaneDivider.border", BasicBorders.getSplitPaneDividerBorder(),
"SplitPaneDivider.draggingColor", new ColorUIResource(Color.DARK_GRAY),
"TabbedPane.ancestorInputMap", new UIDefaults.LazyInputMap(new Object[] {
- "ctrl PAGE_DOWN","navigatePageDown",
+ "ctrl PAGE_DOWN", "navigatePageDown",
"ctrl PAGE_UP", "navigatePageUp",
"ctrl UP", "requestFocus",
"ctrl KP_UP", "requestFocus"
"COPY", "copy",
"ctrl KP_UP", "selectPreviousRowChangeLead",
"PASTE", "paste",
- "shift PAGE_DOWN","scrollDownExtendSelection",
+ "shift PAGE_DOWN", "scrollDownExtendSelection",
"PAGE_DOWN", "scrollDownChangeSelection",
"END", "selectLastColumn",
"shift END", "selectLastColumnExtendSelection",
"HOME", "selectFirstColumn",
"ctrl END", "selectLastRow",
- "ctrl shift END","selectLastRowExtendSelection",
+ "ctrl shift END", "selectLastRowExtendSelection",
"LEFT", "selectPreviousColumn",
"shift HOME", "selectFirstColumnExtendSelection",
"UP", "selectPreviousRow",
"ctrl HOME", "selectFirstRow",
"shift LEFT", "selectPreviousColumnExtendSelection",
"DOWN", "selectNextRow",
- "ctrl shift HOME","selectFirstRowExtendSelection",
+ "ctrl shift HOME", "selectFirstRowExtendSelection",
"shift UP", "selectPreviousRowExtendSelection",
"F2", "startEditing",
"shift RIGHT", "selectNextColumnExtendSelection",
{
if (e.getPropertyName() == "accelerator")
{
- InputMap map = SwingUtilities.getUIInputMap(menuItem, JComponent.WHEN_IN_FOCUSED_WINDOW);
+ InputMap map = SwingUtilities.getUIInputMap(menuItem,
+ JComponent.WHEN_IN_FOCUSED_WINDOW);
if (map != null)
- map.remove((KeyStroke)e.getOldValue());
+ map.remove((KeyStroke) e.getOldValue());
else
map = new ComponentInputMapUIResource(menuItem);
*/
public Dimension getPreferredSize(JComponent c)
{
- return getPreferredMenuItemSize(c, checkIcon, arrowIcon, defaultTextIconGap);
+ return getPreferredMenuItemSize(c, checkIcon, arrowIcon,
+ defaultTextIconGap);
}
/**
prefix + ".foreground", prefix + ".font");
menuItem.setMargin(UIManager.getInsets(prefix + ".margin"));
acceleratorFont = UIManager.getFont(prefix + ".acceleratorFont");
- acceleratorForeground = UIManager.getColor(prefix + ".acceleratorForeground");
- acceleratorSelectionForeground = UIManager.getColor(prefix + ".acceleratorSelectionForeground");
+ acceleratorForeground = UIManager.getColor(prefix
+ + ".acceleratorForeground");
+ acceleratorSelectionForeground = UIManager.getColor(prefix
+ + ".acceleratorSelectionForeground");
selectionBackground = UIManager.getColor(prefix + ".selectionBackground");
selectionForeground = UIManager.getColor(prefix + ".selectionForeground");
acceleratorDelimiter = UIManager.getString(prefix + ".acceleratorDelimiter");
*/
protected void installKeyboardActions()
{
- InputMap focusedWindowMap = SwingUtilities.getUIInputMap(menuItem, JComponent.WHEN_IN_FOCUSED_WINDOW);
+ InputMap focusedWindowMap = SwingUtilities.getUIInputMap(menuItem,
+ JComponent.WHEN_IN_FOCUSED_WINDOW);
if (focusedWindowMap == null)
focusedWindowMap = new ComponentInputMapUIResource(menuItem);
KeyStroke accelerator = menuItem.getAccelerator();
if (accelerator != null)
focusedWindowMap.put(accelerator, "doClick");
- SwingUtilities.replaceUIInputMap(menuItem, JComponent.WHEN_IN_FOCUSED_WINDOW, focusedWindowMap);
+ SwingUtilities.replaceUIInputMap(menuItem,
+ JComponent.WHEN_IN_FOCUSED_WINDOW, focusedWindowMap);
ActionMap UIActionMap = SwingUtilities.getUIActionMap(menuItem);
if (UIActionMap == null)
Insets insets = m.getInsets();
viewRect.x += insets.left;
viewRect.y += insets.top;
- viewRect.width -= (insets.left + insets.right);
- viewRect.height -= (insets.top + insets.bottom);
+ viewRect.width -= insets.left + insets.right;
+ viewRect.height -= insets.top + insets.bottom;
// Fetch the fonts.
Font font = m.getFont();
((JDialog) owner).dispose();
//else we probably have some kind of internal frame.
- JInternalFrame inf = (JInternalFrame) SwingUtilities.getAncestorOfClass(JInternalFrame.class,
- optionPane);
+ JInternalFrame inf = (JInternalFrame) SwingUtilities.getAncestorOfClass(
+ JInternalFrame.class, optionPane);
if (inf != null)
{
try
public static final int MinimumHeight = 90;
/** Whether the JOptionPane contains custom components. */
- protected boolean hasCustomComponents = false;
+ protected boolean hasCustomComponents;
// The initialFocusComponent seems to always be set to a button (even if
// I try to set initialSelectionValue). This is different from what the
if (remainder.length() == 0)
return;
- // Recursivly call ourselves to burst the remainder of the string,
- if ((remainder.length() > maxll || remainder.contains("\n")))
+ // Recursively call ourselves to burst the remainder of the string,
+ if (remainder.length() > maxll || remainder.contains("\n"))
burstStringInto(c, remainder, maxll);
else
// Add the remainder to the container and be done.
case JOptionPane.DEFAULT_OPTION:
return (optionPane.getWantsInput()) ?
new Object[] { OK_STRING, CANCEL_STRING } :
- ( optionPane.getMessageType() == JOptionPane.QUESTION_MESSAGE ) ?
+ (optionPane.getMessageType() == JOptionPane.QUESTION_MESSAGE) ?
new Object[] { YES_STRING, NO_STRING, CANCEL_STRING } :
// ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, PLAIN_MESSAGE
new Object[] { OK_STRING };
}
int index = getAnimationIndex();
- if (animationIndex > (numFrames) / 2)
+ if (animationIndex > numFrames / 2)
index = numFrames - getAnimationIndex();
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
else
{
g.setColor(c.getForeground());
- g.fillRect(vr.x, vr.y + vr.height - amountFull, vr.width, amountFull);
+ g.fillRect(vr.x, vr.y + vr.height - amountFull, vr.width,
+ amountFull);
}
if (progressBar.isStringPainted() && !progressBar.getString().equals(""))
*
* @return a new instance of <code>BasicRadioButtonUI</code>
*/
- public static ComponentUI createUI(final JComponent c) {
+ public static ComponentUI createUI(final JComponent c)
+ {
return new BasicRadioButtonUI();
}
currentIcon = b.getDisabledIcon();
SwingUtilities.calculateInnerArea(b, vr);
- String text = SwingUtilities.layoutCompoundLabel
- (c, g.getFontMetrics(f), b.getText(), currentIcon,
+ String text = SwingUtilities.layoutCompoundLabel(c, g.getFontMetrics(f),
+ b.getText(), currentIcon,
b.getVerticalAlignment(), b.getHorizontalAlignment(),
b.getVerticalTextPosition(), b.getHorizontalTextPosition(),
vr, ir, tr, b.getIconTextGap() + defaultTextShiftOffset);
/* BasicScrollBarUI.java --
- Copyright (C) 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, Free Software Foundation, Inc.
This file is part of GNU Classpath.
package javax.swing.plaf.basic;
-import gnu.classpath.NotImplementedException;
-
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
+import javax.swing.AbstractAction;
+import javax.swing.ActionMap;
import javax.swing.BoundedRangeModel;
+import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JScrollBar;
+import javax.swing.JSlider;
import javax.swing.LookAndFeel;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
+import javax.swing.plaf.ActionMapUIResource;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.ScrollBarUI;
return false;
if (direction == POSITIVE_SCROLL)
- return (value > scrollbar.getValue());
+ return value > scrollbar.getValue();
else
- return (value < scrollbar.getValue());
+ return value < scrollbar.getValue();
}
}
int orientation = scrollbar.getOrientation();
switch (orientation)
{
- case (JScrollBar.HORIZONTAL):
+ case JScrollBar.HORIZONTAL:
incrButton = createIncreaseButton(EAST);
decrButton = createDecreaseButton(WEST);
break;
}
/**
- * This method installs the keyboard actions for the scrollbar.
+ * Installs the input map from the look and feel defaults, and a
+ * corresponding action map. Note the the keyboard bindings will only
+ * work when the {@link JScrollBar} component has the focus, which is rare.
*/
protected void installKeyboardActions()
- throws NotImplementedException
{
- // FIXME: implement.
+ InputMap keyMap = getInputMap(
+ JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
+ SwingUtilities.replaceUIInputMap(scrollbar,
+ JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keyMap);
+ ActionMap map = getActionMap();
+ SwingUtilities.replaceUIActionMap(scrollbar, map);
+ }
+
+ /**
+ * Uninstalls the input map and action map installed by
+ * {@link #installKeyboardActions()}.
+ */
+ protected void uninstallKeyboardActions()
+ {
+ SwingUtilities.replaceUIActionMap(scrollbar, null);
+ SwingUtilities.replaceUIInputMap(scrollbar,
+ JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
+ }
+
+ InputMap getInputMap(int condition)
+ {
+ if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
+ return (InputMap) UIManager.get("ScrollBar.focusInputMap");
+ return null;
+ }
+
+ /**
+ * Returns the action map for the {@link JScrollBar}. All scroll bars
+ * share a single action map which is created the first time this method is
+ * called, then stored in the UIDefaults table for subsequent access.
+ *
+ * @return The shared action map.
+ */
+ ActionMap getActionMap()
+ {
+ ActionMap map = (ActionMap) UIManager.get("ScrollBar.actionMap");
+
+ if (map == null) // first time here
+ {
+ map = createActionMap();
+ if (map != null)
+ UIManager.put("ScrollBar.actionMap", map);
+ }
+ return map;
}
/**
+ * Creates the action map shared by all {@link JSlider} instances.
+ * This method is called once by {@link #getActionMap()} when it
+ * finds no action map in the UIDefaults table...after the map is
+ * created, it gets added to the defaults table so that subsequent
+ * calls to {@link #getActionMap()} will return the same shared
+ * instance.
+ *
+ * @return The action map.
+ */
+ ActionMap createActionMap()
+ {
+ ActionMap map = new ActionMapUIResource();
+ map.put("positiveUnitIncrement",
+ new AbstractAction("positiveUnitIncrement") {
+ public void actionPerformed(ActionEvent event)
+ {
+ JScrollBar sb = (JScrollBar) event.getSource();
+ if (sb.isVisible())
+ {
+ int delta = sb.getUnitIncrement(1);
+ sb.setValue(sb.getValue() + delta);
+ }
+ }
+ }
+ );
+ map.put("positiveBlockIncrement",
+ new AbstractAction("positiveBlockIncrement") {
+ public void actionPerformed(ActionEvent event)
+ {
+ JScrollBar sb = (JScrollBar) event.getSource();
+ if (sb.isVisible())
+ {
+ int delta = sb.getBlockIncrement(1);
+ sb.setValue(sb.getValue() + delta);
+ }
+ }
+ }
+ );
+ map.put("negativeUnitIncrement",
+ new AbstractAction("negativeUnitIncrement") {
+ public void actionPerformed(ActionEvent event)
+ {
+ JScrollBar sb = (JScrollBar) event.getSource();
+ if (sb.isVisible())
+ {
+ int delta = sb.getUnitIncrement(-1);
+ sb.setValue(sb.getValue() + delta);
+ }
+ }
+ }
+ );
+ map.put("negativeBlockIncrement",
+ new AbstractAction("negativeBlockIncrement") {
+ public void actionPerformed(ActionEvent event)
+ {
+ JScrollBar sb = (JScrollBar) event.getSource();
+ if (sb.isVisible())
+ {
+ int delta = sb.getBlockIncrement(-1);
+ sb.setValue(sb.getValue() + delta);
+ }
+ }
+ }
+ );
+ map.put("minScroll",
+ new AbstractAction("minScroll") {
+ public void actionPerformed(ActionEvent event)
+ {
+ JScrollBar sb = (JScrollBar) event.getSource();
+ if (sb.isVisible())
+ {
+ sb.setValue(sb.getMinimum());
+ }
+ }
+ }
+ );
+ map.put("maxScroll",
+ new AbstractAction("maxScroll") {
+ public void actionPerformed(ActionEvent event)
+ {
+ JScrollBar sb = (JScrollBar) event.getSource();
+ if (sb.isVisible())
+ {
+ sb.setValue(sb.getMaximum());
+ }
+ }
+ }
+ );
+ return map;
+ }
+
+ /**
* This method installs any listeners for the scrollbar. This method also
* installs listeners for things such as the JButtons and the timer.
*/
super.installUI(c);
if (c instanceof JScrollBar)
{
- scrollbar = (JScrollBar) c;
+ scrollbar = (JScrollBar) c;
- trackRect = new Rectangle();
- thumbRect = new Rectangle();
+ trackRect = new Rectangle();
+ thumbRect = new Rectangle();
- scrollTimer = new Timer(300, null);
+ scrollTimer = new Timer(300, null);
installDefaults();
- installComponents();
- configureScrollBarColors();
- installListeners();
+ installComponents();
+ configureScrollBarColors();
+ installListeners();
+ installKeyboardActions();
- calculatePreferredSize();
+ calculatePreferredSize();
}
}
}
/**
- * This method uninstalls any keyboard actions this scrollbar acquired
- * during install.
- */
- protected void uninstallKeyboardActions()
- throws NotImplementedException
- {
- // FIXME: implement.
- }
-
- /**
* This method uninstalls any listeners that were registered during install.
*/
protected void uninstallListeners()
*/
public void uninstallUI(JComponent c)
{
+ uninstallKeyboardActions();
uninstallListeners();
uninstallDefaults();
uninstallComponents();
// If the length is 0, you shouldn't be able to even see where the thumb is.
// This really shouldn't ever happen, but just in case, we'll return the middle.
if (len == 0)
- return ((max - min) / 2);
+ return (max - min) / 2;
- value = ((yPos - trackRect.y) * (max - min) / len + min);
+ value = (yPos - trackRect.y) * (max - min) / len + min;
// If this isn't a legal value, then we'll have to move to one now.
if (value > max)
// If the length is 0, you shouldn't be able to even see where the slider is.
// This really shouldn't ever happen, but just in case, we'll return the middle.
if (len == 0)
- return ((max - min) / 2);
+ return (max - min) / 2;
- value = ((xPos - trackRect.x) * (max - min) / len + min);
+ value = (xPos - trackRect.x) * (max - min) / len + min;
// If this isn't a legal value, then we'll have to move to one now.
if (value > max)
{
map = createActionMap();
if (map != null)
- UIManager.put("Slider.actionMap", map);
+ UIManager.put("ScrollPane.actionMap", map);
}
return map;
}
import javax.swing.JLabel;
import javax.swing.JSlider;
import javax.swing.LookAndFeel;
-import javax.swing.RepaintManager;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.UIManager;
value = valueForYPosition(currentMouseY);
if (direction == POSITIVE_SCROLL)
- return (value > slider.getValue());
+ return value > slider.getValue();
else
- return (value < slider.getValue());
+ return value < slider.getValue();
}
}
Dimension d = getThumbSize();
thumbRect.width = d.width;
thumbRect.height = d.height;
- if (slider.getOrientation() == JSlider.HORIZONTAL)
- thumbRect.y = trackRect.y;
- else
- thumbRect.x = trackRect.x;
}
/**
if (slider.getOrientation() == JSlider.HORIZONTAL)
{
thumbRect.x = xPositionForValue(value) - thumbRect.width / 2;
- thumbRect.y = trackRect.y;
+ thumbRect.y = trackRect.y + 1;
}
else
{
- thumbRect.x = trackRect.x;
+ thumbRect.x = trackRect.x + 1;
thumbRect.y = yPositionForValue(value) - thumbRect.height / 2;
}
}
tickRect.x = trackRect.x;
tickRect.y = trackRect.y + trackRect.height;
tickRect.width = trackRect.width;
- tickRect.height = (slider.getPaintTicks() ? getTickLength() : 0);
+ tickRect.height = slider.getPaintTicks() ? getTickLength() : 0;
+
+ // this makes our Mauve tests pass...can't explain it!
+ if (!slider.getPaintTicks())
+ tickRect.y--;
if (tickRect.y + tickRect.height > contentRect.y + contentRect.height)
tickRect.height = contentRect.y + contentRect.height - tickRect.y;
{
tickRect.x = trackRect.x + trackRect.width;
tickRect.y = trackRect.y;
- tickRect.width = (slider.getPaintTicks() ? getTickLength() : 0);
+ tickRect.width = slider.getPaintTicks() ? getTickLength() : 0;
tickRect.height = trackRect.height;
+ // this makes our Mauve tests pass...can't explain it!
+ if (!slider.getPaintTicks())
+ tickRect.x--;
+
if (tickRect.x + tickRect.width > contentRect.x + contentRect.width)
tickRect.width = contentRect.x + contentRect.width - tickRect.x;
}
}
/**
- * This method calculates the size and position of the labelRect. It must
- * take into account the orientation of the slider.
+ * Calculates the <code>labelRect</code> field, taking into account the
+ * orientation of the slider.
*/
protected void calculateLabelRect()
{
if (slider.getOrientation() == JSlider.HORIZONTAL)
{
- labelRect.x = contentRect.x;
- labelRect.y = tickRect.y + tickRect.height;
- labelRect.width = contentRect.width;
+ if (slider.getPaintLabels())
+ {
+ labelRect.x = contentRect.x;
+ labelRect.y = tickRect.y + tickRect.height - 1;
+ labelRect.width = contentRect.width;
+ }
+ else
+ {
+ labelRect.x = trackRect.x;
+ labelRect.y = tickRect.y + tickRect.height;
+ labelRect.width = trackRect.width;
+ }
labelRect.height = getHeightOfTallestLabel();
}
else
{
- labelRect.x = tickRect.x + tickRect.width;
- labelRect.y = contentRect.y;
+ if (slider.getPaintLabels())
+ {
+ labelRect.x = tickRect.x + tickRect.width - 1;
+ labelRect.y = contentRect.y;
+ labelRect.height = contentRect.height;
+ }
+ else
+ {
+ labelRect.x = tickRect.x + tickRect.width;
+ labelRect.y = trackRect.y;
+ labelRect.height = trackRect.height;
+ }
labelRect.width = getWidthOfWidestLabel();
- labelRect.height = contentRect.height;
}
}
int width;
int height;
- Point a = new Point(trackRect.x, trackRect.y);
+ Point a = new Point(trackRect.x, trackRect.y + 1);
Point b = new Point(a);
Point c = new Point(a);
Point d = new Point(a);
// is. This really shouldn't ever happen, but just in case, we'll return
// the middle.
if (len == 0)
- return ((max - min) / 2);
+ return (max - min) / 2;
if (! drawInverted())
- value = ((len - (yPos - trackRect.y)) * (max - min) / len + min);
+ value = (len - (yPos - trackRect.y)) * (max - min) / len + min;
else
- value = ((yPos - trackRect.y) * (max - min) / len + min);
+ value = (yPos - trackRect.y) * (max - min) / len + min;
// If this isn't a legal value, then we'll have to move to one now.
if (value > max)
// is. This really shouldn't ever happen, but just in case, we'll return
// the middle.
if (len == 0)
- return ((max - min) / 2);
+ return (max - min) / 2;
if (! drawInverted())
- value = ((xPos - trackRect.x) * (max - min) / len + min);
+ value = (xPos - trackRect.x) * (max - min) / len + min;
else
- value = ((len - (xPos - trackRect.x)) * (max - min) / len + min);
+ value = (len - (xPos - trackRect.x)) * (max - min) / len + min;
// If this isn't a legal value, then we'll have to move to one now.
if (value > max)
int tabPlacement = tabPane.getTabPlacement();
Insets insets = tabPane.getInsets();
+
+ int selectedIndex = tabPane.getSelectedIndex();
+
+ Component selectedComponent = null;
+ if (selectedIndex >= 0)
+ selectedComponent = tabPane.getComponentAt(selectedIndex);
+ // The RI doesn't seem to change the component if the new selected
+ // component == null. This is probably so that applications can add
+ // one single component for every tab.
+ if (selectedComponent != null)
+ {
+ setVisibleComponent(selectedComponent);
+ }
+
int childCount = tabPane.getComponentCount();
if (childCount > 0)
{
private boolean tabsOpaque;
/**
+ * The currently visible component.
+ */
+ private Component visibleComponent;
+
+ /**
* Creates a new BasicTabbedPaneUI object.
*/
public BasicTabbedPaneUI()
*/
protected Component getVisibleComponent()
{
- return tabPane.getComponentAt(tabPane.getSelectedIndex());
+ return visibleComponent;
}
/**
*/
protected void setVisibleComponent(Component component)
{
- component.setVisible(true);
- tabPane.setSelectedComponent(component);
+ // Make old component invisible.
+ if (visibleComponent != null && visibleComponent != component
+ && visibleComponent.getParent() == tabPane)
+ {
+ visibleComponent.setVisible(false);
+ }
+
+ // Make new component visible.
+ if (component != null && ! component.isVisible())
+ {
+ component.setVisible(true);
+ }
+ visibleComponent = component;
}
/**
originalCursor = header.getCursor();
if (p < x)
- header.setCursor(Cursor.getPredefinedCursor
- (Cursor.W_RESIZE_CURSOR));
+ header.setCursor(Cursor.getPredefinedCursor(
+ Cursor.W_RESIZE_CURSOR));
else
- header.setCursor(Cursor.getPredefinedCursor
- (Cursor.E_RESIZE_CURSOR));
+ header.setCursor(Cursor.getPredefinedCursor(
+ Cursor.E_RESIZE_CURSOR));
}
else
{
int x = e.getX();
int p = 0;
- int col = model.getColumnCount()-1;
+ int col = model.getColumnCount() - 1;
int n = model.getColumnCount();
// This loop does not find the column if the mouse if out of the
comp.setBackground(header.getBackground());
comp.setForeground(header.getForeground());
if (comp instanceof JComponent)
- ((JComponent)comp).setBorder(cellBorder);
+ ((JComponent) comp).setBorder(cellBorder);
rendererPane.paintComponent(gfx, comp, header, bounds.x, bounds.y,
bounds.width, bounds.height);
}
// This displays a running rectangle that is much simplier than the total
// animation, as it is seen in Sun's application.
// TODO animate the collumn dragging like in Sun's jre.
- if (draggingHeaderRect!=null)
+ if (draggingHeaderRect != null)
{
gfx.setColor(header.getForeground());
- gfx.drawRect(draggingHeaderRect.x, draggingHeaderRect.y+2,
- draggingHeaderRect.width-1, draggingHeaderRect.height-6);
+ gfx.drawRect(draggingHeaderRect.x, draggingHeaderRect.y + 2,
+ draggingHeaderRect.width - 1, draggingHeaderRect.height - 6);
}
}
TableColumnModel cmod = header.getColumnModel();
TableCellRenderer defaultRend = header.getDefaultRenderer();
int ncols = cmod.getColumnCount();
- Dimension ret = new Dimension(0,0);
+ Dimension ret = new Dimension(0, 0);
int spacing = 0;
if (header.getTable() != null
comp.setBackground(header.getBackground());
comp.setForeground(header.getForeground());
if (comp instanceof JComponent)
- ((JComponent)comp).setBorder(cellBorder);
+ ((JComponent) comp).setBorder(cellBorder);
Dimension d = comp.getPreferredSize();
ret.width += spacing;
begin = new Point(e.getX(), e.getY());
curr = new Point(e.getX(), e.getY());
//if control is pressed and the cell is already selected, deselect it
- if (e.isControlDown() && table.
- isCellSelected(table.rowAtPoint(begin),table.columnAtPoint(begin)))
+ if (e.isControlDown() && table.isCellSelected(
+ table.rowAtPoint(begin), table.columnAtPoint(begin)))
{
table.getSelectionModel().
removeSelectionInterval(table.rowAtPoint(begin),
// Register key bindings in the UI InputMap-ActionMap pair
for (int i = 0; i < keys.length; i++)
{
- KeyStroke stroke = (KeyStroke)keys[i];
+ KeyStroke stroke = (KeyStroke) keys[i];
String actionString = (String) ancestorMap.get(stroke);
parentInputMap.put(KeyStroke.getKeyStroke(stroke.getKeyCode(),
stroke.getModifiers()),
actionString);
- parentActionMap.put (actionString,
- new ActionListenerProxy (action, actionString));
+ parentActionMap.put(actionString,
+ new ActionListenerProxy(action, actionString));
}
// Set the UI InputMap-ActionMap pair to be the parents of the
// JTable's InputMap-ActionMap pair
- parentInputMap.setParent
- (table.getInputMap
- (JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).getParent());
+ parentInputMap.setParent(table.getInputMap(
+ JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).getParent());
parentActionMap.setParent(table.getActionMap().getParent());
table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).
setParent(parentInputMap);
*
* @param e the ActionEvent that caused this action.
*/
- public void actionPerformed (ActionEvent e)
+ public void actionPerformed(ActionEvent e)
{
- DefaultListSelectionModel rowModel = (DefaultListSelectionModel) table.getSelectionModel();
- DefaultListSelectionModel colModel = (DefaultListSelectionModel) table.getColumnModel().getSelectionModel();
+ DefaultListSelectionModel rowModel
+ = (DefaultListSelectionModel) table.getSelectionModel();
+ DefaultListSelectionModel colModel
+ = (DefaultListSelectionModel) table.getColumnModel().getSelectionModel();
int rowLead = rowModel.getLeadSelectionIndex();
int rowMax = table.getModel().getRowCount() - 1;
else if (command.equals("startEditing"))
{
if (table.isCellEditable(rowLead, colLead))
- table.editCellAt(rowLead,colLead);
+ table.editCellAt(rowLead, colLead);
}
else if (command.equals("selectFirstRowExtendSelection"))
{
}
else if (command.equals("selectLastRow"))
{
- rowModel.setSelectionInterval(rowMax,rowMax);
+ rowModel.setSelectionInterval(rowMax, rowMax);
}
else if (command.equals("selectNextRowExtendSelection"))
{
}
else if (command.equals("selectFirstRow"))
{
- rowModel.setSelectionInterval(0,0);
+ rowModel.setSelectionInterval(0, 0);
}
else if (command.equals("selectNextColumnExtendSelection"))
{
{
int target;
if (rowLead == getFirstVisibleRowIndex())
- target = Math.max
- (0, rowLead - (getLastVisibleRowIndex() -
- getFirstVisibleRowIndex() + 1));
+ target = Math.max(0, rowLead - (getLastVisibleRowIndex()
+ - getFirstVisibleRowIndex() + 1));
else
target = getFirstVisibleRowIndex();
{
int target;
if (colLead == getLastVisibleColumnIndex())
- target = Math.min
- (colMax, colLead + (getLastVisibleColumnIndex() -
- getFirstVisibleColumnIndex() + 1));
+ target = Math.min(colMax, colLead + (getLastVisibleColumnIndex()
+ - getFirstVisibleColumnIndex() + 1));
else
target = getLastVisibleColumnIndex();
{
int target;
if (colLead == getFirstVisibleColumnIndex())
- target = Math.max
- (0, colLead - (getLastVisibleColumnIndex() -
- getFirstVisibleColumnIndex() + 1));
+ target = Math.max(0, colLead - (getLastVisibleColumnIndex()
+ - getFirstVisibleColumnIndex() + 1));
else
target = getFirstVisibleColumnIndex();
{
if (command.indexOf("Column") != -1)
advanceSingleSelection(colModel, colMax, rowModel, rowMax,
- (command.equals
- ("selectPreviousColumnCell")));
+ command.equals("selectPreviousColumnCell"));
else
advanceSingleSelection(rowModel, rowMax, colModel, colMax,
- (command.equals
- ("selectPreviousRowCell")));
+ command.equals("selectPreviousRowCell"));
return;
}
// cell and wrap at the edges of the selection.
if (command.indexOf("Column") != -1)
advanceMultipleSelection(colModel, colMinSelected, colMaxSelected,
- rowModel, rowMinSelected, rowMaxSelected,
- (command.equals
- ("selectPreviousColumnCell")), true);
+ rowModel, rowMinSelected, rowMaxSelected,
+ command.equals("selectPreviousColumnCell"), true);
else
advanceMultipleSelection(rowModel, rowMinSelected, rowMaxSelected,
- colModel, colMinSelected, colMaxSelected,
- (command.equals
- ("selectPreviousRowCell")), false);
+ colModel, colMinSelected, colMaxSelected,
+ command.equals("selectPreviousRowCell"), false);
}
else if (command.equals("selectNextColumn"))
{
{
int target;
if (colLead == getFirstVisibleColumnIndex())
- target = Math.max
- (0, colLead - (getLastVisibleColumnIndex() -
- getFirstVisibleColumnIndex() + 1));
+ target = Math.max(0, colLead - (getLastVisibleColumnIndex()
+ - getFirstVisibleColumnIndex() + 1));
else
target = getFirstVisibleColumnIndex();
{
int target;
if (rowLead == getLastVisibleRowIndex())
- target = Math.min
- (rowMax, rowLead + (getLastVisibleRowIndex() -
- getFirstVisibleRowIndex() + 1));
+ target = Math.min(rowMax, rowLead + (getLastVisibleRowIndex()
+ - getFirstVisibleRowIndex() + 1));
else
target = getLastVisibleRowIndex();
{
int target;
if (colLead == getLastVisibleColumnIndex())
- target = Math.min
- (colMax, colLead + (getLastVisibleColumnIndex() -
- getFirstVisibleColumnIndex() + 1));
+ target = Math.min(colMax, colLead + (getLastVisibleColumnIndex()
+ - getFirstVisibleColumnIndex() + 1));
else
target = getLastVisibleColumnIndex();
{
int target;
if (rowLead == getLastVisibleRowIndex())
- target = Math.min
- (rowMax, rowLead + (getLastVisibleRowIndex() -
- getFirstVisibleRowIndex() + 1));
+ target = Math.min(rowMax, rowLead + (getLastVisibleRowIndex()
+ - getFirstVisibleRowIndex() + 1));
else
target = getLastVisibleRowIndex();
{
int target;
if (rowLead == getFirstVisibleRowIndex())
- target = Math.max
- (0, rowLead - (getLastVisibleRowIndex() -
- getFirstVisibleRowIndex() + 1));
+ target = Math.max(0, rowLead - (getLastVisibleRowIndex()
+ - getFirstVisibleRowIndex() + 1));
else
target = getFirstVisibleRowIndex();
}
else if (command.equals("selectNextRowChangeLead"))
{
- if (rowModel.getSelectionMode() != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
+ if (rowModel.getSelectionMode()
+ != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
{
// just "selectNextRow"
rowModel.setSelectionInterval(Math.min(rowLead + 1, rowMax),
Math.min(rowLead + 1, rowMax));
- colModel.setSelectionInterval(colLead,colLead);
+ colModel.setSelectionInterval(colLead, colLead);
}
else
rowModel.moveLeadSelectionIndex(Math.min(rowLead + 1, rowMax));
}
else if (command.equals("selectPreviousRowChangeLead"))
{
- if (rowModel.getSelectionMode() != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
+ if (rowModel.getSelectionMode()
+ != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
{
// just selectPreviousRow
rowModel.setSelectionInterval(Math.max(rowLead - 1, 0),
- Math.min(rowLead -1, 0));
- colModel.setSelectionInterval(colLead,colLead);
+ Math.min(rowLead - 1, 0));
+ colModel.setSelectionInterval(colLead, colLead);
}
else
rowModel.moveLeadSelectionIndex(Math.max(rowLead - 1, 0));
}
else if (command.equals("selectNextColumnChangeLead"))
{
- if (colModel.getSelectionMode() != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
+ if (colModel.getSelectionMode()
+ != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
{
// just selectNextColumn
- rowModel.setSelectionInterval(rowLead,rowLead);
+ rowModel.setSelectionInterval(rowLead, rowLead);
colModel.setSelectionInterval(Math.min(colLead + 1, colMax),
Math.min(colLead + 1, colMax));
}
}
else if (command.equals("selectPreviousColumnChangeLead"))
{
- if (colModel.getSelectionMode() != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
+ if (colModel.getSelectionMode()
+ != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
{
// just selectPreviousColumn
- rowModel.setSelectionInterval(rowLead,rowLead);
+ rowModel.setSelectionInterval(rowLead, rowLead);
colModel.setSelectionInterval(Math.max(colLead - 1, 0),
Math.max(colLead - 1, 0));
&& command != "addToSelection")
table.editingStopped(new ChangeEvent("update"));
- table.scrollRectToVisible
- (table.getCellRect(rowModel.getLeadSelectionIndex(),
- colModel.getLeadSelectionIndex(), false));
+ table.scrollRectToVisible(table.getCellRect(
+ rowModel.getLeadSelectionIndex(), colModel.getLeadSelectionIndex(),
+ false));
}
/**
* @param reverse true if shift was held for the event
* @param eventIsTab true if TAB was pressed, false if ENTER pressed
*/
- void advanceMultipleSelection (ListSelectionModel firstModel, int firstMin,
- int firstMax, ListSelectionModel secondModel,
- int secondMin, int secondMax, boolean reverse,
- boolean eventIsTab)
+ void advanceMultipleSelection(ListSelectionModel firstModel, int firstMin,
+ int firstMax, ListSelectionModel secondModel,
+ int secondMin, int secondMax, boolean reverse,
+ boolean eventIsTab)
{
- // If eventIsTab, all the "firsts" correspond to columns, otherwise, to rows
- // "seconds" correspond to the opposite
+ // If eventIsTab, all the "firsts" correspond to columns, otherwise, to
+ // rows "seconds" correspond to the opposite
int firstLead = firstModel.getLeadSelectionIndex();
int secondLead = secondModel.getLeadSelectionIndex();
int numFirsts = eventIsTab ?
* @param reverse true if SHIFT was pressed for the event
*/
- void advanceSingleSelection (ListSelectionModel firstModel, int firstMax,
- ListSelectionModel secondModel, int secondMax,
- boolean reverse)
+ void advanceSingleSelection(ListSelectionModel firstModel, int firstMax,
+ ListSelectionModel secondModel, int secondMax,
+ boolean reverse)
{
// for TABs, "first" corresponds to columns and "seconds" to rows.
// the opposite is true for ENTERs
// do we have to wrap the "seconds"?
if (reverse && (firstLead == 0) || !reverse && (firstLead == firstMax))
- secondModel.setSelectionInterval((secondLead + 1)%(secondMax + 1),
- (secondLead + 1)%(secondMax + 1));
+ secondModel.setSelectionInterval((secondLead + 1) % (secondMax + 1),
+ (secondLead + 1) % (secondMax + 1));
// if not, just reselect the current lead
else
secondModel.setSelectionInterval(secondLead, secondLead);
firstLead -= 2;
}
// select the next "first"
- firstModel.setSelectionInterval ((firstLead + 1)%(firstMax + 1),
- (firstLead + 1)%(firstMax + 1));
+ firstModel.setSelectionInterval((firstLead + 1) % (firstMax + 1),
+ (firstLead + 1) % (firstMax + 1));
}
}
public void installUI(JComponent comp)
{
- table = (JTable)comp;
+ table = (JTable) comp;
rendererPane = new CellRendererPane();
table.add(rendererPane);
int rowMargin = table.getRowMargin();
TableColumnModel cmodel = table.getColumnModel();
- int [] widths = new int[cn+1];
- for (int i = c0; i <=cn ; i++)
+ int[] widths = new int[cn + 1];
+ for (int i = c0; i <= cn; i++)
{
widths[i] = cmodel.getColumn(i).getWidth() - columnMargin;
}
// Fetch the colors for enabled/disabled text components.
background = UIManager.getColor(prefix + ".background");
inactiveBackground = UIManager.getColor(prefix + ".inactiveBackground");
- textComponent.setDisabledTextColor
- (UIManager.getColor(prefix + ".inactiveForeground"));
- textComponent.setSelectedTextColor(UIManager.getColor(prefix + ".selectionForeground"));
- textComponent.setSelectionColor(UIManager.getColor(prefix + ".selectionBackground"));
+ textComponent.setDisabledTextColor(UIManager.getColor(prefix
+ + ".inactiveForeground"));
+ textComponent.setSelectedTextColor(UIManager.getColor(prefix
+ + ".selectionForeground"));
+ textComponent.setSelectionColor(UIManager.getColor(prefix
+ + ".selectionBackground"));
}
/**
Clipboard cb = Toolkit.getDefaultToolkit().getSystemSelection();
if (cb != null)
{
- StringSelection selection = new StringSelection(textComponent.getSelectedText());
+ StringSelection selection = new StringSelection(
+ textComponent.getSelectedText());
cb.setContents(selection, selection);
}
}
*/
protected void uninstallKeyboardActions()
{
- SwingUtilities.replaceUIInputMap(textComponent, JComponent.WHEN_FOCUSED, null);
+ SwingUtilities.replaceUIInputMap(textComponent, JComponent.WHEN_FOCUSED,
+ null);
SwingUtilities.replaceUIActionMap(textComponent, null);
}
&& Utilities.getRowStart(t, nextPosBelow) != p1RowStart)
{
posBelow = nextPosBelow;
- nextPosBelow = Utilities.getPositionBelow(t, posBelow, l1.x);
+ nextPosBelow = Utilities.getPositionBelow(t, posBelow,
+ l1.x);
if (posBelow == nextPosBelow)
break;
}
- // Now posBelow is an offset on the last line which has to be damaged
- // completely. (newPosBelow is on the same line as p1)
+ // Now posBelow is an offset on the last line which has to be
+ // damaged completely. (newPosBelow is on the same line as p1)
// Retrieve the rectangle of posBelow and use its y and height
// value to calculate the final height of the multiple line
int w = 0;
int h = 0;
- boolean tmp = ((loc == SwingConstants.NORTH)
- || (loc == SwingConstants.SOUTH) || (loc == -1));
+ boolean tmp = (loc == SwingConstants.NORTH)
+ || (loc == SwingConstants.SOUTH) || (loc == -1);
cachedOrientation = toolBar.getOrientation();
cachedBounds = toolBar.getSize();
isDragging = true;
if (dragWindow != null)
- dragWindow.setOffset(new Point(cachedBounds.width/2, cachedBounds.height/2));
+ dragWindow.setOffset(new Point(cachedBounds.width / 2,
+ cachedBounds.height / 2));
dragTo(e.getPoint(), origin);
}
int gap = 4;
/** The max height of the nodes in the tree. */
- int maxHeight = 0;
+ int maxHeight;
/** The hash color. */
Color hashColor;
{
Enumeration expanded = tree.getExpandedDescendants(path);
while (expanded.hasMoreElements())
- treeState.setExpandedState(((TreePath) expanded.nextElement()), true);
+ treeState.setExpandedState((TreePath) expanded.nextElement(), true);
}
/**
*/
protected TreePath getLastChildPath(TreePath parent)
{
- return ((TreePath) parent.getLastPathComponent());
+ return (TreePath) parent.getLastPathComponent();
}
/**
ActionMapUIResource am = new ActionMapUIResource();
Action action;
- action= new TreeAction();
+ action = new TreeAction();
am.put(action.getValue(Action.NAME), action);
// TreeHomeAction.
- action= new TreeHomeAction(-1, "selectFirst");
+ action = new TreeHomeAction(-1, "selectFirst");
am.put(action.getValue(Action.NAME), action);
- action= new TreeHomeAction(-1, "selectFirstChangeLead");
+ action = new TreeHomeAction(-1, "selectFirstChangeLead");
am.put(action.getValue(Action.NAME), action);
- action= new TreeHomeAction(-1, "selectFirstExtendSelection");
+ action = new TreeHomeAction(-1, "selectFirstExtendSelection");
am.put(action.getValue(Action.NAME), action);
- action= new TreeHomeAction(1, "selectLast");
+ action = new TreeHomeAction(1, "selectLast");
am.put(action.getValue(Action.NAME), action);
- action= new TreeHomeAction(1, "selectLastChangeLead");
+ action = new TreeHomeAction(1, "selectLastChangeLead");
am.put(action.getValue(Action.NAME), action);
- action= new TreeHomeAction(1, "selectLastExtendSelection");
+ action = new TreeHomeAction(1, "selectLastExtendSelection");
am.put(action.getValue(Action.NAME), action);
// TreeIncrementAction.
if (treeSelectionModel != null
&& selectionModelPropertyChangeListener != null)
{
- treeSelectionModel.addPropertyChangeListener
- (selectionModelPropertyChangeListener);
+ treeSelectionModel.addPropertyChangeListener(
+ selectionModelPropertyChangeListener);
}
componentListener = createComponentListener();
Insets i = tree.getInsets();
int left = getRowX(tree.getRowForPath(path), path.getPathCount() - 1)
- -getRightChildIndent() - width / 2 + i.left;
+ - getRightChildIndent() - width / 2 + i.left;
cntlClick = mouseX >= left && mouseX <= left + width;
}
return cntlClick;
{
cancelEditing(tree);
}
- }// CellEditorHandler
+ } // CellEditorHandler
/**
* Repaints the lead selection row when focus is lost/grained.
void repaintLeadRow()
{
TreePath lead = tree.getLeadSelectionPath();
- if (lead!=null)
+ if (lead != null)
tree.repaint(tree.getPathBounds(lead));
}
}
{
return BasicTreeUI.this.getRowX(row, depth);
}
- }// NodeDimensionsHandler
+ } // NodeDimensionsHandler
/**
* PropertyChangeListener for the tree. Updates the appropriate variable, or
tree.revalidate();
tree.repaint();
}
- }// TreeExpansionHandler
+ } // TreeExpansionHandler
/**
* TreeHomeAction is used to handle end/home actions. Scrolls either the first
treeState.treeStructureChanged(e);
tree.repaint();
}
- }// TreeModelHandler
+ } // TreeModelHandler
/**
* TreePageAction handles page up and page down events.
}
else
{
- newVisible.y -= (visible.height - newVisible.height);
+ newVisible.y -= visible.height - newVisible.height;
newVisible.height = visible.height;
}
{
return (tree != null) && tree.isEnabled();
}
- }// TreePageAction
+ } // TreePageAction
/**
* Listens for changes in the selection model and updates the display
Rectangle n = treeState.getBounds(event.getNewLeadSelectionPath(),
new Rectangle());
- if (o!=null)
+ if (o != null)
tree.repaint(o);
- if (n!=null)
+ if (n != null)
tree.repaint(n);
}
}
- }// TreeSelectionHandler
+ } // TreeSelectionHandler
/**
* For the first selected row expandedness will be toggled.
// is not visible.
TreePath parent = current.getParentPath();
if (parent != null &&
- !(parent.getPathCount()==1 && !tree.isRootVisible()) )
+ ! (parent.getPathCount() == 1 && ! tree.isRootVisible()))
tree.setSelectionPath(parent);
}
}
if (parent != null)
{
Rectangle parentBounds = getPathBounds(tree, parent);
- paintVerticalLine(g, tree, parentBounds.x + 2* gap,
+ paintVerticalLine(g, tree, parentBounds.x + 2 * gap,
parentBounds.y + parentBounds.height / 2,
bounds.y + bounds.height / 2);
}
boolean isLeaf)
{
Object node = path.getLastPathComponent();
- return (! isLeaf && hasControlIcons());
+ return ! isLeaf && hasControlIcons();
}
/**
package javax.swing.plaf.metal;
import java.awt.Color;
-import java.awt.Container;
+import java.awt.Component;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import javax.swing.JComponent;
import javax.swing.JToolBar;
import javax.swing.SwingConstants;
-import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.UIResource;
public void update(Graphics g, JComponent c)
{
AbstractButton b = (AbstractButton) c;
- if (b.isContentAreaFilled()
- && (UIManager.get(getPropertyPrefix() + "gradient") != null)
- && b.isEnabled()
- && (b.getBackground() instanceof UIResource))
- updateWidthGradient(g, b, b.getParent());
- else
- super.update(g, c);
- }
-
- private void updateWidthGradient(Graphics g, AbstractButton b, Container parent)
- {
- ButtonModel m = b.getModel();
- String gradientPropertyName = getPropertyPrefix() + "gradient";
-
- // Gradient painting behavior depends on whether the button is part of a
- // JToolBar.
- if (parent instanceof JToolBar)
+ if ((b.getBackground() instanceof UIResource)
+ && b.isContentAreaFilled() && b.isEnabled())
{
- if (! m.isPressed() && ! m.isArmed())
+ ButtonModel m = b.getModel();
+ String uiKey = "Button.gradient";
+ if (! isToolbarButton(b))
{
- if (m.isRollover())
+ if (! m.isArmed() && ! m.isPressed() && isDrawingGradient(uiKey))
{
- // Paint the gradient when the mouse cursor hovers over the
- // button but is not pressed down.
MetalUtils.paintGradient(g, 0, 0, b.getWidth(), b.getHeight(),
SwingConstants.VERTICAL,
- gradientPropertyName);
- }
- else
- {
- // If mouse does not hover over the button let the JToolBar
- // paint itself at the location where the button is (the button
- // is transparent).
-
- // There where cases where the button was not repainted and
- // therefore showed its old state. With this statement it does
- // not happen.
- b.repaint();
-
- Rectangle area = new Rectangle();
- SwingUtilities.calculateInnerArea(b, area);
- SwingUtilities.convertRectangle(b, area, b.getParent());
- b.getParent().repaint(area.x, area.y, area.width, area.height);
+ uiKey);
+ paint(g, c);
+ return;
}
}
-
- }
- else if (! m.isPressed() && ! m.isArmed())
- {
- // When the button is not part of a JToolBar just paint itself with a
- // gradient and everything is fine.
- MetalUtils.paintGradient(g, 0, 0, b.getWidth(), b.getHeight(),
- SwingConstants.VERTICAL,
- gradientPropertyName);
+ else if (m.isRollover() && isDrawingGradient(uiKey))
+ {
+ MetalUtils.paintGradient(g, 0, 0, b.getWidth(), b.getHeight(),
+ SwingConstants.VERTICAL,
+ uiKey);
+ paint(g, c);
+ return;
+ }
}
-
- paint(g, b);
+ // Fallback if we didn't have any of the two above cases.
+ super.update(g, c);
+ }
+
+ /**
+ * Returns <code>true</code> when the button is a toolbar button,
+ * <code>false</code> otherwise.
+ *
+ * @param b the button component to test
+ *
+ * @return <code>true</code> when the button is a toolbar button,
+ * <code>false</code> otherwise
+ */
+ private boolean isToolbarButton(Component b)
+ {
+ Component parent = b.getParent();
+ return parent instanceof JToolBar;
+ }
+
+ /**
+ * Returns <code>true</code> if we should draw the button gradient,
+ * <code>false</code> otherwise.
+ *
+ * @param uiKey the UIManager key for the gradient
+ *
+ * @return <code>true</code> if we should draw the button gradient,
+ * <code>false</code> otherwise
+ */
+ private boolean isDrawingGradient(String uiKey)
+ {
+ return (UIManager.get(uiKey) != null);
}
-
}
* This mask is used to paint the gradient in the shape of the thumb.
*/
int[][] gradientMask = new int[][] { {0, 12}, {0, 12}, {0, 12}, {0, 12},
- {0, 12}, {0, 12}, {0, 12}, {1, 12},
+ {0, 12}, {0, 12}, {0, 12}, {1, 11},
{2, 10}, {3, 9}, {4, 8}, {5, 7},
{6, 6}};
* This mask is used to paint the gradient in the shape of the thumb.
*/
int[][] gradientMask = new int[][] { {0, 12}, {0, 12}, {0, 12}, {0, 12},
- {0, 12}, {0, 12}, {0, 12}, {1, 12},
+ {0, 12}, {0, 12}, {0, 12}, {1, 11},
{2, 10}, {3, 9}, {4, 8}, {5, 7},
{6, 6}};
Edit edit = getEditForParagraphAndIndex(paragraph, index);
edit.addAddedElement(leaf);
-
- if (end != toRec.getEndOffset())
- {
- recreateLeaves(end, toRec, onlyContent);
-
- if (onlyContent)
- edit.addRemovedElement(target);
- }
}
else
paragraph.replace(0, 0, new Element[] { leaf });
int mid = 0;
while (low <= hi)
{
- mid = (low + hi) >> 1;
+ mid = (low + hi) >>> 1;
final int d = a[mid];
if (d == key)
return mid;
package javax.swing.text.html;
import gnu.classpath.NotImplementedException;
-
import gnu.javax.swing.text.html.CharacterAttributeTranslator;
+
import java.io.IOException;
import java.net.URL;
import java.util.HashMap;
import java.util.Stack;
import java.util.Vector;
+
+import javax.swing.JEditorPane;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.html.HTML.Tag;
/**
- * TODO: Add more comments here
+ * Represents the HTML document that is constructed by defining the text and
+ * other components (images, buttons, etc) in HTML language. This class can
+ * becomes the default document for {@link JEditorPane} after setting its
+ * content type to "text/html". HTML document also serves as an intermediate
+ * data structure when it is needed to parse HTML and then obtain the content of
+ * the certain types of tags. This class also has methods for modifying the HTML
+ * content.
*
- * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
* @author Anthony Balkissoon (abalkiss@redhat.com)
* @author Lillian Angel (langel@redhat.com)
*/
}
}
- public class HiddenAction extends TagAction
+ /**
+ * This action indicates that the content between starting and closing HTML
+ * elements (like script - /script) should not be visible. The content is
+ * still inserted and can be accessed when iterating the HTML document. The
+ * parser will only fire
+ * {@link javax.swing.text.html.HTMLEditorKit.ParserCallback#handleText} for
+ * the hidden tags, regardless from that html tags the hidden section may
+ * contain.
+ */
+ public class HiddenAction
+ extends TagAction
{
/**
* This method is called when a start tag is seen for one of the types
* of tags associated with this Action.
*/
public void start(HTML.Tag t, MutableAttributeSet a)
- throws NotImplementedException
{
- // FIXME: Implement.
- print ("HiddenAction.start not implemented");
+ blockOpen(t, a);
}
/**
* with this Action.
*/
public void end(HTML.Tag t)
- throws NotImplementedException
{
- // FIXME: Implement.
- print ("HiddenAction.end not implemented");
+ blockClose(t);
}
}
}
}
+ /**
+ * Inserts the elements that are represented by ths single tag with
+ * attributes (only). The closing tag, even if present, mut follow
+ * immediately after the starting tag without providing any additional
+ * information. Hence the {@link TagAction#end} method need not be
+ * overridden and still does nothing.
+ */
public class SpecialAction extends TagAction
{
/**
- * This method is called when a start tag is seen for one of the types
- * of tags associated with this Action.
+ * The functionality is delegated to {@link HTMLReader#addSpecialElement}
*/
public void start(HTML.Tag t, MutableAttributeSet a)
{
* @param a the attribute set specifying the special content
*/
protected void addSpecialElement(HTML.Tag t, MutableAttributeSet a)
- throws NotImplementedException
{
- // FIXME: Implement
- print ("HTMLReader.addSpecialElement not implemented yet");
+ a.addAttribute(StyleConstants.NameAttribute, t);
+
+ // Migrate from the rather htmlAttributeSet to the faster, lighter and
+ // unchangeable alternative implementation.
+ AttributeSet copy = a.copyAttributes();
+
+ // TODO: Figure out why we must always insert this single character
+ // (otherwise the element does not appear). Either fix or add explaining
+ // comment or at least report a normal bug.
+ DefaultStyledDocument.ElementSpec spec;
+ spec = new DefaultStyledDocument.ElementSpec(copy,
+ DefaultStyledDocument.ElementSpec.ContentType,
+ new char[] {' '}, 0, 1 );
+ parseBuffer.add(spec);
}
void printBuffer()
JAWTDIR = jawt
endif
-SUBDIRS = fdlibm $(JNIDIR) $(JAWTDIR) target
-DIST_SUBDIRS = fdlibm jni jawt target
+if CREATE_PLUGIN
+ PLUGINDIR = plugin
+endif
+
+SUBDIRS = fdlibm $(JNIDIR) $(JAWTDIR) $(PLUGINDIR) target
+DIST_SUBDIRS = fdlibm jni jawt plugin target
vm_classes = @vm_classes@
@CREATE_JNI_LIBRARIES_TRUE@JNIDIR = jni
@CREATE_GTK_PEER_LIBRARIES_TRUE@JAWTDIR = jawt
-SUBDIRS = fdlibm $(JNIDIR) $(JAWTDIR) target
-DIST_SUBDIRS = fdlibm jni jawt target
+@CREATE_PLUGIN_TRUE@PLUGINDIR = plugin
+SUBDIRS = fdlibm $(JNIDIR) $(JAWTDIR) $(PLUGINDIR) target
+DIST_SUBDIRS = fdlibm jni jawt plugin target
all: all-recursive
.SUFFIXES:
-nativeexeclib_LTLIBRARIES = libjawt.la
+## GCJ LOCAL: install this library in GCJ's versioned library
+## directory
+gcc_version := $(shell cat $(top_srcdir)/../../gcc/BASE-VER)
+gcjversionedlibdir = $(libdir)/gcj-$(gcc_version)
+gcjversionedlib_LTLIBRARIES = libjawt.la
libjawt_la_SOURCES = jawt.c
libjawt_la_LIBADD = $(top_builddir)/native/jni/gtk-peer/libgtkpeer.la
+## GCJ LOCAL: encode the library path and use GCJ's library version
+libjawt_la_LDFLAGS = -rpath $(gcjversionedlibdir) \
+ -version-info `grep -v '^\#' $(top_srcdir)/../libtool-version`
+
AM_LDFLAGS = @CLASSPATH_MODULE@ @GTK_LIBS@ @PANGOFT2_LIBS@ @X_LIBS@ @XTEST_LIBS@
AM_CPPFLAGS = @CLASSPATH_INCLUDES@
*) f=$$p;; \
esac;
am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
-am__installdirs = "$(DESTDIR)$(nativeexeclibdir)"
-nativeexeclibLTLIBRARIES_INSTALL = $(INSTALL)
-LTLIBRARIES = $(nativeexeclib_LTLIBRARIES)
+am__installdirs = "$(DESTDIR)$(gcjversionedlibdir)"
+gcjversionedlibLTLIBRARIES_INSTALL = $(INSTALL)
+LTLIBRARIES = $(gcjversionedlib_LTLIBRARIES)
libjawt_la_DEPENDENCIES = \
$(top_builddir)/native/jni/gtk-peer/libgtkpeer.la
am_libjawt_la_OBJECTS = jawt.lo
target_os = @target_os@
target_vendor = @target_vendor@
vm_classes = @vm_classes@
-nativeexeclib_LTLIBRARIES = libjawt.la
+gcc_version := $(shell cat $(top_srcdir)/../../gcc/BASE-VER)
+gcjversionedlibdir = $(libdir)/gcj-$(gcc_version)
+gcjversionedlib_LTLIBRARIES = libjawt.la
libjawt_la_SOURCES = jawt.c
libjawt_la_LIBADD = $(top_builddir)/native/jni/gtk-peer/libgtkpeer.la
+libjawt_la_LDFLAGS = -rpath $(gcjversionedlibdir) \
+ -version-info `grep -v '^\#' $(top_srcdir)/../libtool-version`
+
AM_LDFLAGS = @CLASSPATH_MODULE@ @GTK_LIBS@ @PANGOFT2_LIBS@ @X_LIBS@ @XTEST_LIBS@
AM_CPPFLAGS = @CLASSPATH_INCLUDES@
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-install-nativeexeclibLTLIBRARIES: $(nativeexeclib_LTLIBRARIES)
+install-gcjversionedlibLTLIBRARIES: $(gcjversionedlib_LTLIBRARIES)
@$(NORMAL_INSTALL)
- test -z "$(nativeexeclibdir)" || $(mkdir_p) "$(DESTDIR)$(nativeexeclibdir)"
- @list='$(nativeexeclib_LTLIBRARIES)'; for p in $$list; do \
+ test -z "$(gcjversionedlibdir)" || $(mkdir_p) "$(DESTDIR)$(gcjversionedlibdir)"
+ @list='$(gcjversionedlib_LTLIBRARIES)'; for p in $$list; do \
if test -f $$p; then \
f=$(am__strip_dir) \
- echo " $(LIBTOOL) --mode=install $(nativeexeclibLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(nativeexeclibdir)/$$f'"; \
- $(LIBTOOL) --mode=install $(nativeexeclibLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(nativeexeclibdir)/$$f"; \
+ echo " $(LIBTOOL) --mode=install $(gcjversionedlibLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(gcjversionedlibdir)/$$f'"; \
+ $(LIBTOOL) --mode=install $(gcjversionedlibLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(gcjversionedlibdir)/$$f"; \
else :; fi; \
done
-uninstall-nativeexeclibLTLIBRARIES:
+uninstall-gcjversionedlibLTLIBRARIES:
@$(NORMAL_UNINSTALL)
- @set -x; list='$(nativeexeclib_LTLIBRARIES)'; for p in $$list; do \
+ @set -x; list='$(gcjversionedlib_LTLIBRARIES)'; for p in $$list; do \
p=$(am__strip_dir) \
- echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(nativeexeclibdir)/$$p'"; \
- $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(nativeexeclibdir)/$$p"; \
+ echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(gcjversionedlibdir)/$$p'"; \
+ $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(gcjversionedlibdir)/$$p"; \
done
-clean-nativeexeclibLTLIBRARIES:
- -test -z "$(nativeexeclib_LTLIBRARIES)" || rm -f $(nativeexeclib_LTLIBRARIES)
- @list='$(nativeexeclib_LTLIBRARIES)'; for p in $$list; do \
+clean-gcjversionedlibLTLIBRARIES:
+ -test -z "$(gcjversionedlib_LTLIBRARIES)" || rm -f $(gcjversionedlib_LTLIBRARIES)
+ @list='$(gcjversionedlib_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
libjawt.la: $(libjawt_la_OBJECTS) $(libjawt_la_DEPENDENCIES)
- $(LINK) -rpath $(nativeexeclibdir) $(libjawt_la_LDFLAGS) $(libjawt_la_OBJECTS) $(libjawt_la_LIBADD) $(LIBS)
+ $(LINK) -rpath $(gcjversionedlibdir) $(libjawt_la_LDFLAGS) $(libjawt_la_OBJECTS) $(libjawt_la_LIBADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
check: check-am
all-am: Makefile $(LTLIBRARIES)
installdirs:
- for dir in "$(DESTDIR)$(nativeexeclibdir)"; do \
+ for dir in "$(DESTDIR)$(gcjversionedlibdir)"; do \
test -z "$$dir" || $(mkdir_p) "$$dir"; \
done
install: install-am
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
-clean-am: clean-generic clean-libtool clean-nativeexeclibLTLIBRARIES \
+clean-am: clean-gcjversionedlibLTLIBRARIES clean-generic clean-libtool \
mostlyclean-am
distclean: distclean-am
info-am:
-install-data-am:
+install-data-am: install-gcjversionedlibLTLIBRARIES
-install-exec-am: install-nativeexeclibLTLIBRARIES
+install-exec-am:
install-info: install-info-am
ps-am:
-uninstall-am: uninstall-info-am uninstall-nativeexeclibLTLIBRARIES
+uninstall-am: uninstall-gcjversionedlibLTLIBRARIES uninstall-info-am
-.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
- clean-libtool clean-nativeexeclibLTLIBRARIES ctags distclean \
- distclean-compile distclean-generic distclean-libtool \
- distclean-tags distdir dvi dvi-am html html-am info info-am \
- install install-am install-data install-data-am install-exec \
- install-exec-am install-info install-info-am install-man \
- install-nativeexeclibLTLIBRARIES install-strip installcheck \
+.PHONY: CTAGS GTAGS all all-am check check-am clean \
+ clean-gcjversionedlibLTLIBRARIES clean-generic clean-libtool \
+ ctags distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-data \
+ install-data-am install-exec install-exec-am \
+ install-gcjversionedlibLTLIBRARIES install-info \
+ install-info-am install-man install-strip installcheck \
installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
- tags uninstall uninstall-am uninstall-info-am \
- uninstall-nativeexeclibLTLIBRARIES
+ tags uninstall uninstall-am \
+ uninstall-gcjversionedlibLTLIBRARIES uninstall-info-am
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
char *pattern_pixels;
};
-cairo_t *cp_gtk_get_cairo_t(JNIEnv *env,
- jobject cairographics2dobj);
-
#endif
static void install_font_peer(cairo_t *cr, struct peerfont *pfont);
static void update_pattern_transform (struct cairographics2d *gr);
-static struct cairographics2d *getPointer(JNIEnv *env, jobject obj);
-
-static struct cairographics2d *
-getPointer(JNIEnv *env, jobject obj)
-{
- jclass cls;
- jlong value;
- jfieldID nofid;
- cls = (*env)->GetObjectClass( env, obj );
- nofid = (*env)->GetFieldID( env, cls, "nativePointer", "J" );
- value = (*env)->GetLongField( env, obj, nofid );
- (*env)->DeleteLocalRef( env, cls );
-
- return JLONG_TO_PTR(struct cairographics2d, value);
-}
-
-/**
- * Returns the cairo_t * associated with a CairoGraphics2D object,
- * This is used by GdkTextLayout.
- */
-cairo_t *cp_gtk_get_cairo_t(JNIEnv *env,
- jobject cairographics2dobj)
-{
- struct cairographics2d *gr = getPointer(env, cairographics2dobj);
- g_assert(gr != NULL);
- return gr->cr;
-}
/**
* Allocates the cairographics2d structure.
*/
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_CairoGraphics2D_disposeNative
- (JNIEnv *env, jobject obj)
+ (JNIEnv *env __attribute__((unused)), jobject obj __attribute__((unused)),
+ jlong pointer)
{
- struct cairographics2d *gr = getPointer(env, obj);
+ struct cairographics2d *gr = JLONG_TO_PTR(struct cairographics2d, pointer);
if (gr == NULL)
return;
*/
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_CairoGraphics2D_setGradient
- (JNIEnv *env, jobject obj,
+ (JNIEnv *env __attribute__((unused)), jobject obj __attribute__((unused)),
+ jlong pointer,
jdouble x1, jdouble y1,
jdouble x2, jdouble y2,
jint r1, jint g1, jint b1, jint a1,
OSDN Git Service
