| /* QtImage.java -- |
| Copyright (C) 2005, 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.awt.peer.qt; |
| |
| import java.awt.Graphics; |
| import java.awt.Color; |
| import java.awt.Image; |
| import java.awt.image.ColorModel; |
| import java.awt.image.DirectColorModel; |
| import java.awt.image.MemoryImageSource; |
| import java.awt.image.ImageObserver; |
| import java.awt.image.ImageProducer; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.ByteArrayOutputStream; |
| import java.io.BufferedInputStream; |
| import java.net.URL; |
| import java.util.Hashtable; |
| import java.util.WeakHashMap; |
| import java.util.Vector; |
| |
| /** |
| * QtImage - wraps a QImage |
| * |
| */ |
| public class QtImage extends Image |
| { |
| int width = -1, height = -1; |
| |
| /** |
| * Properties. |
| */ |
| Hashtable props; |
| |
| /** |
| * Loaded or not flag, for asynchronous compatibility. |
| */ |
| boolean isLoaded; |
| |
| /** |
| * Pointer to the QImage |
| */ |
| long nativeObject; |
| |
| /** |
| * Observer queue. |
| */ |
| Vector observers; |
| |
| /** |
| * Error flag for loading. |
| */ |
| boolean errorLoading; |
| |
| /** |
| * Original source, if created from an ImageProducer. |
| */ |
| ImageProducer source; |
| |
| /* |
| * The 32-bit AARRGGBB format the uses. |
| */ |
| static ColorModel nativeModel = new DirectColorModel(32, |
| 0x00FF0000, |
| 0x0000FF00, |
| 0x000000FF, |
| 0xFF000000); |
| /** |
| * HashMap of Graphics objects painting on this Image. |
| */ |
| WeakHashMap painters; |
| |
| /** |
| * Flags if this image is to be destroyed. |
| */ |
| boolean killFlag; |
| |
| /** |
| * Clears the image to RGBA 0 |
| */ |
| public native void clear(); |
| |
| /** |
| * Returns a copy of the pixel data as a java array. |
| */ |
| private native int[] getPixels(); |
| |
| /** |
| * Sets the pixel data from a java array. |
| */ |
| private native void setPixels(int[] pixels); |
| |
| /** |
| * Loads an image |
| */ |
| private native boolean loadImage(String name); |
| |
| /** |
| * Loads an image from data. |
| */ |
| private native boolean loadImageFromData(byte[] data); |
| |
| /** |
| * Allocates a QImage |
| */ |
| private native void createImage(); |
| |
| /** |
| * Frees the above. |
| */ |
| private synchronized native void freeImage(); |
| |
| /** |
| * Sets the image to scaled copy of src image. hints are rendering hints. |
| */ |
| private native void createScaledImage(QtImage src, int hints); |
| |
| /** |
| * Draws the image optionally composited. |
| */ |
| native void drawPixels (QtGraphics gc, |
| int bg_red, int bg_green, int bg_blue, |
| int x, int y, |
| boolean composite); |
| /** |
| * Draws the image, optionally scaled and composited. |
| */ |
| private native void drawPixelsScaled (QtGraphics gc, |
| int bg_red, int bg_green, int bg_blue, |
| int x, int y, int width, int height, |
| boolean composite); |
| |
| /** |
| * Draws the image transformed. |
| */ |
| private native void drawPixelsTransformed (QtGraphics gc, QMatrix transform); |
| |
| /** |
| * Draws the image scaled flipped and optionally composited. |
| */ |
| native void drawPixelsScaledFlipped (QtGraphics gc, |
| int bg_red, int bg_green, |
| int bg_blue, |
| boolean flipX, boolean flipY, |
| int srcX, int srcY, |
| int srcWidth, int srcHeight, |
| int dstX, int dstY, |
| int dstWidth, int dstHeight, |
| boolean composite); |
| |
| /** |
| * Creates the image from an ImageProducer. May result in an error image. |
| */ |
| public QtImage (ImageProducer producer) |
| { |
| killFlag = false; |
| isLoaded = false; |
| observers = new Vector(); |
| source = producer; |
| errorLoading = false; |
| if( producer != null ) |
| source.startProduction(new QtImageConsumer(this, source)); |
| } |
| |
| /** |
| * Creates the image from a URL. May result in an error image. |
| */ |
| public QtImage (URL url) |
| { |
| killFlag = false; |
| isLoaded = false; |
| observers = new Vector(); |
| errorLoading = false; |
| if( url == null) |
| return; |
| ByteArrayOutputStream baos = new ByteArrayOutputStream( 5000 ); |
| try |
| { |
| BufferedInputStream bis = new BufferedInputStream(url.openStream()); |
| |
| byte[] buf = new byte[5000]; |
| int n = 0; |
| |
| while ( (n = bis.read( buf )) != -1 ) |
| baos.write(buf, 0, n); |
| bis.close(); |
| } |
| catch(IOException e) |
| { |
| throw new IllegalArgumentException("Couldn't load image."); |
| } |
| if ( loadImageFromData( baos.toByteArray() ) != true ) |
| throw new IllegalArgumentException("Couldn't load image."); |
| |
| isLoaded = true; |
| observers = null; |
| props = new Hashtable(); |
| } |
| |
| /** |
| * Constructs a QtImage by loading a given file. |
| * |
| * @throws IllegalArgumentException if the image could not be loaded. |
| */ |
| public QtImage (String filename) |
| { |
| killFlag = false; |
| File f = new File(filename); |
| observers = null; |
| props = new Hashtable(); |
| try |
| { |
| String fn = f.getCanonicalPath(); |
| if (loadImage( fn ) != true) |
| { |
| errorLoading = true; |
| isLoaded = false; |
| return; |
| } |
| } |
| catch(IOException e) |
| { |
| errorLoading = true; |
| isLoaded = false; |
| return; |
| } |
| errorLoading = false; |
| isLoaded = true; |
| } |
| |
| /** |
| * Constructs a QtImage from a byte array of an image file. |
| * |
| * @throws IllegalArgumentException if the image could not be loaded. |
| */ |
| public QtImage (byte[] data) |
| { |
| if (loadImageFromData(data) != true) |
| throw new IllegalArgumentException("Couldn't load image."); |
| |
| killFlag = false; |
| isLoaded = true; |
| observers = null; |
| errorLoading = false; |
| props = new Hashtable(); |
| } |
| |
| /** |
| * Constructs an empty QtImage. |
| */ |
| public QtImage (int width, int height) |
| { |
| this.width = width; |
| this.height = height; |
| props = new Hashtable(); |
| isLoaded = true; |
| killFlag = false; |
| observers = null; |
| errorLoading = false; |
| createImage(); |
| clear(); |
| } |
| |
| /** |
| * Constructs a scaled version of the src bitmap, using Qt |
| */ |
| private QtImage (QtImage src, int width, int height, int hints) |
| { |
| this.width = width; |
| this.height = height; |
| props = new Hashtable(); |
| isLoaded = true; |
| killFlag = false; |
| observers = null; |
| errorLoading = false; |
| |
| createScaledImage(src, hints); |
| } |
| |
| /** |
| * Callback from the image consumer. |
| */ |
| public void setImage(int width, int height, |
| int[] pixels, Hashtable properties) |
| { |
| this.width = width; |
| this.height = height; |
| props = (properties != null) ? properties : new Hashtable(); |
| |
| if (width <= 0 || height <= 0 || pixels == null) |
| { |
| errorLoading = true; |
| return; |
| } |
| |
| isLoaded = true; |
| deliver(); |
| createImage(); |
| setPixels(pixels); |
| } |
| |
| // java.awt.Image methods //////////////////////////////////////////////// |
| |
| public int getWidth (ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return -1; |
| |
| return width; |
| } |
| |
| public int getHeight (ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return -1; |
| |
| return height; |
| } |
| |
| public Object getProperty (String name, ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return UndefinedProperty; |
| |
| Object value = props.get (name); |
| return (value == null) ? UndefinedProperty : value; |
| } |
| |
| /** |
| * Returns the source of this image. |
| */ |
| public ImageProducer getSource () |
| { |
| if (!isLoaded) |
| return null; |
| return new MemoryImageSource(width, height, nativeModel, getPixels(), |
| 0, width); |
| } |
| |
| void putPainter(QtImageGraphics g) |
| { |
| if( painters == null ) |
| painters = new WeakHashMap(); |
| painters.put( g, "dummy" ); |
| } |
| |
| void removePainter(QtImageGraphics g) |
| { |
| painters.remove( g ); |
| if( killFlag && painters.isEmpty() ) |
| freeImage(); |
| } |
| |
| /** |
| * Creates a Graphics context for this image. |
| */ |
| public Graphics getGraphics () |
| { |
| if (!isLoaded || killFlag) |
| return null; |
| |
| return new QtImageGraphics(this); |
| } |
| |
| /** |
| * Creates a Graphics context for this image. |
| */ |
| Graphics getDirectGraphics(QtComponentPeer peer) |
| { |
| if (!isLoaded) |
| return null; |
| |
| return new QtImageDirectGraphics(this, peer); |
| } |
| |
| /** |
| * Returns a scaled instance of this image. |
| */ |
| public Image getScaledInstance(int width, |
| int height, |
| int hints) |
| { |
| if (width <= 0 || height <= 0) |
| throw new IllegalArgumentException("Width and height of scaled bitmap"+ |
| "must be >= 0"); |
| |
| return new QtImage(this, width, height, hints); |
| } |
| |
| /** |
| * If the image is loaded and comes from an ImageProducer, |
| * regenerate the image from there. |
| * |
| * I have no idea if this is ever actually used. Since QtImage can't be |
| * instantiated directly, how is the user to know if it was created from |
| * an ImageProducer or not? |
| */ |
| public synchronized void flush () |
| { |
| if (isLoaded && source != null) |
| { |
| observers = new Vector(); |
| isLoaded = false; |
| freeImage(); |
| source.startProduction(new QtImageConsumer(this, source)); |
| } |
| } |
| |
| public void finalize() |
| { |
| dispose(); |
| } |
| |
| public void dispose() |
| { |
| if (isLoaded) |
| { |
| if( painters == null || painters.isEmpty() ) |
| freeImage(); |
| else |
| killFlag = true; // can't destroy image yet. |
| // Do so when all painters are gone. |
| } |
| } |
| |
| /** |
| * Returns the image status, used by QtToolkit |
| */ |
| public int checkImage (ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| { |
| if (errorLoading == true) |
| return ImageObserver.ERROR; |
| else |
| return 0; |
| } |
| |
| return ImageObserver.ALLBITS | ImageObserver.WIDTH | ImageObserver.HEIGHT; |
| } |
| |
| // Drawing methods //////////////////////////////////////////////// |
| |
| /** |
| * Draws an image with eventual scaling/transforming. |
| */ |
| public boolean drawImage (QtGraphics g, QMatrix matrix, |
| ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return false; |
| |
| drawPixelsTransformed (g, matrix); |
| |
| return true; |
| } |
| |
| /** |
| * Draws an image to the QtGraphics context, at (x,y) with optional |
| * compositing with a background color. |
| */ |
| public boolean drawImage (QtGraphics g, int x, int y, |
| Color bgcolor, ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return false; |
| |
| if(bgcolor != null) |
| drawPixels(g, bgcolor.getRed (), bgcolor.getGreen (), |
| bgcolor.getBlue (), x, y, true); |
| else |
| drawPixels(g, 0, 0, 0, x, y, false); |
| |
| return true; |
| } |
| |
| /** |
| * Draws an image to the QtGraphics context, at (x,y) scaled to |
| * width and height, with optional compositing with a background color. |
| */ |
| public boolean drawImage (QtGraphics g, int x, int y, int width, int height, |
| Color bgcolor, ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return false; |
| |
| if(bgcolor != null) |
| drawPixelsScaled(g, bgcolor.getRed (), bgcolor.getGreen (), |
| bgcolor.getBlue (), x, y, width, height, true); |
| else |
| drawPixelsScaled(g, 0, 0, 0, x, y, width, height, false); |
| |
| return true; |
| } |
| |
| /** |
| * Draws an image with eventual scaling/transforming. |
| */ |
| public boolean drawImage (QtGraphics g, int dx1, int dy1, int dx2, int dy2, |
| int sx1, int sy1, int sx2, int sy2, |
| Color bgcolor, ImageObserver observer) |
| { |
| if (addObserver(observer)) |
| return false; |
| |
| boolean flipX = (dx1 > dx2)^(sx1 > sx2); |
| boolean flipY = (dy1 > dy2)^(sy1 > sy2); |
| int dstWidth = Math.abs (dx2 - dx1); |
| int dstHeight = Math.abs (dy2 - dy1); |
| int srcWidth = Math.abs (sx2 - sx1); |
| int srcHeight = Math.abs (sy2 - sy1); |
| int srcX = (sx1 < sx2) ? sx1 : sx2; |
| int srcY = (sy1 < sy2) ? sy1 : sy2; |
| int dstX = (dx1 < dx2) ? dx1 : dx2; |
| int dstY = (dy1 < dy2) ? dy1 : dy2; |
| |
| // Clipping. This requires the dst to be scaled as well, |
| if (srcWidth > width) |
| { |
| dstWidth = (int)((double)dstWidth*((double)width/(double)srcWidth)); |
| srcWidth = width - srcX; |
| } |
| |
| if (srcHeight > height) |
| { |
| dstHeight = (int)((double)dstHeight*((double)height/(double)srcHeight)); |
| srcHeight = height - srcY; |
| } |
| |
| if (srcWidth + srcX > width) |
| { |
| dstWidth = (int)((double)dstWidth * (double)(width - srcX)/(double)srcWidth); |
| srcWidth = width - srcX; |
| } |
| |
| if (srcHeight + srcY > height) |
| { |
| dstHeight = (int)((double)dstHeight * (double)(width - srcY)/(double)srcHeight); |
| srcHeight = height - srcY; |
| } |
| |
| if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0) |
| return true; |
| |
| if(bgcolor != null) |
| drawPixelsScaledFlipped (g, bgcolor.getRed (), bgcolor.getGreen (), |
| bgcolor.getBlue (), |
| flipX, flipY, |
| srcX, srcY, |
| srcWidth, srcHeight, |
| dstX, dstY, |
| dstWidth, dstHeight, |
| true); |
| else |
| drawPixelsScaledFlipped (g, 0, 0, 0, flipX, flipY, |
| srcX, srcY, srcWidth, srcHeight, |
| dstX, dstY, dstWidth, dstHeight, |
| false); |
| return true; |
| } |
| |
| public native void copyArea(int x, int y, int width, int height, |
| int dx, int dy); |
| |
| // Private methods //////////////////////////////////////////////// |
| |
| /** |
| * Delivers notifications to all queued observers. |
| */ |
| private void deliver() |
| { |
| int flags = ImageObserver.HEIGHT | |
| ImageObserver.WIDTH | |
| ImageObserver.PROPERTIES | |
| ImageObserver.ALLBITS; |
| |
| if (observers != null) |
| for(int i=0; i < observers.size(); i++) |
| ((ImageObserver)observers.elementAt(i)). |
| imageUpdate(this, flags, 0, 0, width, height); |
| |
| observers = null; |
| } |
| |
| /** |
| * Adds an observer, if we need to. |
| * @return true if an observer was added. |
| */ |
| private boolean addObserver(ImageObserver observer) |
| { |
| if (!isLoaded) |
| { |
| if(observer != null) |
| if (!observers.contains (observer)) |
| observers.addElement (observer); |
| return true; |
| } |
| return false; |
| } |
| |
| public String toString() |
| { |
| return "QtImage [isLoaded="+isLoaded+", width="+width+", height="+height |
| +"]"; |
| } |
| } |