From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/gnu/awt/j2d/IntegerGraphicsState.java | 427 ++++++++++++++++++++++++++ 1 file changed, 427 insertions(+) create mode 100644 libjava/gnu/awt/j2d/IntegerGraphicsState.java (limited to 'libjava/gnu/awt/j2d/IntegerGraphicsState.java') diff --git a/libjava/gnu/awt/j2d/IntegerGraphicsState.java b/libjava/gnu/awt/j2d/IntegerGraphicsState.java new file mode 100644 index 000000000..bcfacd008 --- /dev/null +++ b/libjava/gnu/awt/j2d/IntegerGraphicsState.java @@ -0,0 +1,427 @@ +/* Copyright (C) 2000, 2003 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.awt.j2d; + +import java.awt.Color; +import java.awt.Image; +import java.awt.Shape; +import java.awt.Rectangle; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.GraphicsConfiguration; +import java.awt.Font; +import java.awt.FontMetrics; +import java.awt.image.BufferedImage; +import java.awt.image.ImageObserver; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.ColorModel; + +/** + * IntegerGraphicsState is one of several graphics state + * implementations. This graphics state is used when the graphics + * object has simple properties, (coordinate translation only, no + * transform) and the backend supports integer coordinates (pixel + * based). For primitive paint operations, this object translates the + * coordinates and forwards the request to the backend. For requests + * to draw arbitrary shapes and paths, this object translates the + * requests to primitive drawing operations supported by the + * backend. IntegerGraphicsState is meant to support the most common + * state of an graphics object. The degree of functionality is roughly + * equivalent with the old java.awt.Graphics API. + */ +public class IntegerGraphicsState extends AbstractGraphicsState +{ + int tx; + int ty; + + DirectRasterGraphics directGfx; + Shape clip; + + /** Interface for images which are coupled to a GraphicsConfiguration, + * as is typically the case for an off-screen buffer used in + * double-buffering. Any image which implements this interface is + * rendered directly by DirectRasterGraphics (i.e. by directGfx.drawImage) + */ + public interface ScreenCoupledImage + { + /** Get the GraphicsConfiguration to which this image is coupled + * @return the GraphicsConfiguration + */ + GraphicsConfiguration getGraphicsConfiguration (); + } + + public IntegerGraphicsState(DirectRasterGraphics directGfx) + { + this.directGfx = directGfx; + } + + public Object clone() + { + IntegerGraphicsState clone = (IntegerGraphicsState) super.clone(); + clone.directGfx = (DirectRasterGraphics) directGfx.clone(); + + return clone; + } + + public void dispose() + { + DirectRasterGraphics lDeviceGfx = directGfx; + + directGfx = null; + + if (lDeviceGfx != null) + lDeviceGfx.dispose(); + + super.dispose(); + } + + // -------- Graphics methods: + + public void setColor(Color color) + { + directGfx.setColor(color); + } + + public void setPaintMode() + { + directGfx.setPaintMode(); + } + + public void setXORMode(Color altColor) + { + directGfx.setXORMode(altColor); + } + + public void setFont(Font font) + { + directGfx.setFont(font); + } + + public FontMetrics getFontMetrics(Font font) + { + return directGfx.getFontMetrics(font); + } + + public void setClip(Shape clip) + { + if (clip instanceof Rectangle) + { + Rectangle clipRect = (Rectangle) ((Rectangle) clip).clone(); + clipRect.x += tx; + clipRect.y += ty; + + this.clip = clipRect; + + directGfx.setClip(clipRect); + return; + } + + String msg = + "translating clip shape " + clip + " into device " + + "coordinate space has not been implemented yet"; + + throw new UnsupportedOperationException(msg); + } + + public Shape getClip() + { + if (clip == null) + return null; + if (clip instanceof Rectangle) + { + Rectangle clipRect = (Rectangle) ((Rectangle) clip).clone(); + clipRect.x -= tx; + clipRect.y -= ty; + return clipRect; + } + + String msg = + "translating clip shape " + clip + " into user " + + "coordinate space has not been implemented yet"; + + throw new UnsupportedOperationException(msg); + } + + public Rectangle getClipBounds() + { + if (clip == null) + return null; + Rectangle clipRect = clip.getBounds(); + + clipRect.x -= tx; + clipRect.y -= ty; + return clipRect; + } + + public void copyArea(int x, int y, + int width, int height, + int dx, int dy) + { + directGfx.copyArea(x+tx, y+ty, width, height, dx, dy); + } + + public void drawLine(int x1, int y1, + int x2, int y2) + { + directGfx.drawLine(x1+tx, y1+ty, x2+tx, y2+ty); + } + + public void fillRect(int x, int y, + int width, int height) + { + directGfx.fillRect(x+tx, y+ty, width, height); + } + + public void clearRect(int x, int y, + int width, int height) + { + directGfx.setColor(frontend.getBackground()); + directGfx.fillRect(x+tx, y+ty, width, height); + directGfx.setColor(frontend.getColor()); + } + + public void drawRoundRect(int x, int y, + int width, int height, + int arcWidth, int arcHeight) + { + throw new UnsupportedOperationException("not implemented yet"); + } + + public void fillRoundRect(int x, int y, + int width, int height, + int arcWidth, int arcHeight) + { + throw new UnsupportedOperationException("not implemented yet"); + } + + public void drawOval(int x, int y, + int width, int height) + { + drawArc (x, y, width, height, 0, 360); + } + + public void fillOval(int x, int y, + int width, int height) + { + fillArc (x, y, width, height, 0, 360); + } + + public void drawArc(int x, int y, + int width, int height, + int startAngle, int arcAngle) + { + directGfx.drawArc(x+tx, y+ty, width, height, startAngle, arcAngle); + } + + public void fillArc(int x, int y, + int width, int height, + int startAngle, int arcAngle) + { + directGfx.fillArc(x+tx, y+ty, width, height, startAngle, arcAngle); + } + + public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) + { + if ((tx == 0) && (ty == 0)) + { + directGfx.drawPolyline(xPoints, yPoints, nPoints); + return; + } + + throw new UnsupportedOperationException("translate not implemented"); + } + + public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) + { + if ((tx == 0) && (ty == 0)) + { + directGfx.drawPolygon(xPoints, yPoints, nPoints); + return; + } + + throw new UnsupportedOperationException("translate not implemented"); + } + + public void fillPolygon (int[] xPoints, int[] yPoints, int nPoints) + { + // FIXME: remove tx & ty args once translation via AffineTransform + // is implemented. + directGfx.fillPolygon (xPoints, yPoints, nPoints, tx, ty); + } + + public boolean drawImage(Image image, int x, int y, + ImageObserver observer) + { + x += tx; + y += ty; + + if (image instanceof ScreenCoupledImage) + { + GraphicsConfiguration config + = ((ScreenCoupledImage)image).getGraphicsConfiguration (); + if (config == frontend.config) + return directGfx.drawImage (image, x, y, observer); + } + if (image instanceof BufferedImage) + { + BufferedImage bImage = (BufferedImage) image; + // FIXME: eliminate? ScreenCoupledImage is probably more efficient + Object config = bImage.getProperty ("java.awt.GraphicsConfiguration"); + if (config == frontend.config) + return directGfx.drawImage (image, x, y, observer); + + int width = image.getWidth (null); + int height = image.getHeight (null); + + Rectangle bounds = new Rectangle (x, y, width, height); + + MappedRaster mr = directGfx.mapRaster (bounds); + + // manipulate raster here... + ColorModel colorModel = mr.getColorModel (); + WritableRaster raster = mr.getRaster (); + + int xEnd = x + width; + int yEnd = y + height; + + // FIXME: Use the following code only as a fallback. It's SLOW! + + Object rgbElem = null; + for (int yy=0; yy>> 24) & 0xff) + 1; + int sr = ((srgb >>> 16) & 0xff) + 1; + int sg = ((srgb >>> 8) & 0xff) + 1; + int sb = (srgb & 0xff) + 1; + + rgbElem = raster.getDataElements (xx+x, yy+y, rgbElem); + int drgb = colorModel.getRGB (rgbElem); + int dr = ((drgb >>> 16) & 0xff) + 1; + int dg = ((drgb >>> 8) & 0xff) + 1; + int db = (drgb & 0xff) + 1; + int da = 256 - sa; + + dr = ((sr*sa + dr*da) >>> 8) - 1; + dg = ((sg*sa + dg*da) >>> 8) - 1; + db = ((sb*sa + db*da) >>> 8) - 1; + + drgb = (dr<<16) | (dg<<8) | db; + + rgbElem = colorModel.getDataElements (drgb, rgbElem); + + raster.setDataElements (xx+x, yy+y, rgbElem); + } + } + directGfx.unmapRaster (mr); + return true; + + } + throw new UnsupportedOperationException ("drawing image " + image + + "not implemented"); + } + + + // -------- Graphics2D methods: + + public void draw(Shape shape) + { + if (shape instanceof Rectangle) + { + Rectangle rect = (Rectangle) shape; + directGfx.drawRect(rect.x+tx, rect.y+ty, rect.width, rect.height); + return; + } + + throw new UnsupportedOperationException("shape not implemented"); + } + + public void fill(Shape shape) + { + if (shape instanceof Rectangle) + { + Rectangle rect = (Rectangle) shape; + directGfx.fillRect(rect.x+tx, rect.y+ty, rect.width, rect.height); + return; + } + + throw new UnsupportedOperationException("not implemented"); + } + + public boolean hit(Rectangle rect, Shape text, + boolean onStroke) + { + throw new UnsupportedOperationException("not implemented"); + } + + public void drawString(String text, int x, int y) + { + directGfx.drawString(text, x+tx, y+ty); + } + + public void drawString(String text, float x, float y) + { + drawString(text, (int) x, (int) y); + } + + public void translate(int x, int y) + { + tx += x; + ty += y; + } + + public void translate(double tx, double ty) + { + if ((tx == 0) && (ty == 0)) + return; + + needAffineTransform(); + } + + public void rotate(double theta) + { + if (theta == 0) + return; + + needAffineTransform(); + } + + public void rotate(double theta, double x, double y) + { + if (theta == 0) + return; + + needAffineTransform(); + } + + public void scale(double scaleX, double scaleY) + { + if ((scaleX == 1) && (scaleY == 1)) + return; + + needAffineTransform(); + } + + public void shear(double shearX, double shearY) + { + if ((shearX == 0) && (shearY == 0)) + return; + + needAffineTransform(); + } + + private void needAffineTransform() + { + throw new UnsupportedOperationException("state with affine " + + "transform not implemented"); + } +} -- cgit v1.2.3