From d041c878a2feb668fc0608be77db342b57138265 Mon Sep 17 00:00:00 2001 From: Roman Kennke Date: Tue, 5 Dec 2006 11:11:16 +0000 Subject: 2006-12-05 Roman Kennke * gnu/java/awt/peer/gtk/AsyncImage.java: New class. Supports asynchronous loading of images. * gnu/java/awt/peer/gtk/CairoGraphics2D.java (drawImage): Fetch real image from possibly AsyncImage. * gnu/java/awt/peer/gtk/ComponentGraphics.java (drawImage): Fetch real image from possibly AsyncImage. * gnu/java/awt/peer/gtk/GtkToolkit.java (createImage(URL)): Create async image. (imageOrError): Made method static for easy access from AsyncImage. (prepareImage): For async images, register the observer to the image. --- ChangeLog | 25 +-- gnu/java/awt/peer/gtk/AsyncImage.java | 257 +++++++++++++++++++++++++++ gnu/java/awt/peer/gtk/CairoGraphics2D.java | 2 +- gnu/java/awt/peer/gtk/ComponentGraphics.java | 1 + gnu/java/awt/peer/gtk/GtkToolkit.java | 20 +-- 5 files changed, 282 insertions(+), 23 deletions(-) create mode 100644 gnu/java/awt/peer/gtk/AsyncImage.java diff --git a/ChangeLog b/ChangeLog index 61b4678a2..1bd1f90bb 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,17 @@ +2006-12-05 Roman Kennke + + * gnu/java/awt/peer/gtk/AsyncImage.java: New class. Supports + asynchronous loading of images. + * gnu/java/awt/peer/gtk/CairoGraphics2D.java + (drawImage): Fetch real image from possibly AsyncImage. + * gnu/java/awt/peer/gtk/ComponentGraphics.java + (drawImage): Fetch real image from possibly AsyncImage. + * gnu/java/awt/peer/gtk/GtkToolkit.java + (createImage(URL)): Create async image. + (imageOrError): Made method static for easy access from AsyncImage. + (prepareImage): For async images, register the observer to the + image. + 2006-12-05 Roman Kennke (paintComponent): Include paint area from event. @@ -21,17 +35,6 @@ * javax/swing/text/html/CSS.java (parseMarginShorthand): Remove debug output. -2006-12-04 Roman Kennke - - * gnu/java/awt/peer/gtk/AsyncImage.java: New class. Supports - asynchronous loading of images. - * gnu/java/awt/peer/gtk/CairoGraphics2D.java - * gnu/java/awt/peer/gtk/CairoSurface.java - * gnu/java/awt/peer/gtk/ComponentGraphics.java - * gnu/java/awt/peer/gtk/GtkComponentPeer.java - * gnu/java/awt/peer/gtk/GtkImage.java - * gnu/java/awt/peer/gtk/GtkToolkit.java - 2006-12-04 Roman Kennke * javax/swing/text/GlyphView.java diff --git a/gnu/java/awt/peer/gtk/AsyncImage.java b/gnu/java/awt/peer/gtk/AsyncImage.java new file mode 100644 index 000000000..855e1d604 --- /dev/null +++ b/gnu/java/awt/peer/gtk/AsyncImage.java @@ -0,0 +1,257 @@ +/* AsyncImage.java -- Loads images asynchronously + 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.awt.peer.gtk; + +import java.awt.Graphics; +import java.awt.Image; +import java.awt.image.ImageConsumer; +import java.awt.image.ImageObserver; +import java.awt.image.ImageProducer; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; + +/** + * Supports asynchronous loading of images. + */ +public class AsyncImage + extends Image +{ + + /** + * Returned as source as long as the image is not complete. + */ + private class NullImageSource + implements ImageProducer + { + private ArrayList consumers; + + NullImageSource() + { + consumers = new ArrayList(); + } + + public void addConsumer(ImageConsumer ic) + { + consumers.add(ic); + } + + public boolean isConsumer(ImageConsumer ic) + { + return consumers.contains(ic); + } + + public void removeConsumer(ImageConsumer ic) + { + consumers.remove(ic); + } + + public void requestTopDownLeftRightResend(ImageConsumer ic) + { + startProduction(ic); + } + + public void startProduction(ImageConsumer ic) + { + consumers.add(ic); + for (int i = consumers.size() - 1; i >= 0; i--) + { + ImageConsumer c = (ImageConsumer) consumers.get(i); + c.setDimensions(1, 1); + ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE); + } + } + + } + + /** + * Loads the image asynchronously. + */ + private class Loader + implements Runnable + { + private URL url; + Loader(URL u) + { + url = u; + } + + public void run() + { + Image image; + try + { + GtkImage gtkImage = new GtkImage(url); + image = CairoSurface.getBufferedImage(gtkImage); + } + catch (IllegalArgumentException iae) + { + image = null; + } + realImage = GtkToolkit.imageOrError(image); + notifyObservers(ImageObserver.ALLBITS | ImageObserver.HEIGHT + | ImageObserver.WIDTH | ImageObserver.PROPERTIES); + } + } + + /** + * The real image. This is null as long as the image is not complete. + */ + Image realImage; + + private HashSet observers; + + /** + * Creates a new AsyncImage that loads from the specified URL. + */ + AsyncImage(URL url) + { + observers = new HashSet(); + Loader l = new Loader(url); + Thread t = new Thread(l); + t.start(); + } + + public void flush() + { + // Nothing to do here. + } + + public Graphics getGraphics() + { + Image r = realImage; + Graphics g = null; + if (r != null) + g = r.getGraphics(); // Should we return some dummy graphics instead? + return g; + } + + public int getHeight(ImageObserver observer) + { + synchronized (observers) + { + observers.add(observer); + } + int height = 0; + Image r = realImage; + if (r != null) + height = r.getHeight(observer); + return height; + } + + public Object getProperty(String name, ImageObserver observer) + { + synchronized (observers) + { + observers.add(observer); + } + Image r = realImage; + Object prop = null; + if (r != null) + prop = r.getProperty(name, observer); + return prop; + } + + public ImageProducer getSource() + { + Image r = realImage; + ImageProducer source; + if (r == null) + source = new NullImageSource(); + else + source = r.getSource(); + return source; + } + + public int getWidth(ImageObserver observer) + { + synchronized (observers) + { + observers.add(observer); + } + int width = 0; + Image r = realImage; + if (r != null) + width = r.getWidth(observer); + return width; + } + + void addObserver(ImageObserver obs) + { + if (realImage != null && ! observers.contains(obs)) + { + obs.imageUpdate(this, ImageObserver.WIDTH | ImageObserver.HEIGHT + |ImageObserver.ALLBITS | ImageObserver.PROPERTIES, + 0, 0, realImage.getWidth(null), + realImage.getHeight(null)); + } + synchronized (observers) + { + observers.add(obs); + } + } + + static Image realImage(Image img, ImageObserver obs) + { + if (img instanceof AsyncImage) + { + ((AsyncImage) img).addObserver(obs); + Image r = ((AsyncImage) img).realImage; + if (r != null) + img = r; + } + return img; + } + + void notifyObservers(int status) + { + synchronized (observers) + { + Image r = realImage; + Iterator i = observers.iterator(); + while (i.hasNext()) + { + ImageObserver obs = (ImageObserver) i.next(); + obs.imageUpdate(this, status, 0, 0, r.getWidth(null), + r.getHeight(null)); + } + } + } +} diff --git a/gnu/java/awt/peer/gtk/CairoGraphics2D.java b/gnu/java/awt/peer/gtk/CairoGraphics2D.java index ec9890524..348801800 100644 --- a/gnu/java/awt/peer/gtk/CairoGraphics2D.java +++ b/gnu/java/awt/peer/gtk/CairoGraphics2D.java @@ -1463,7 +1463,7 @@ public abstract class CairoGraphics2D extends Graphics2D // 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. - + img = AsyncImage.realImage(img, obs); if( !(img instanceof BufferedImage) ) { ImageProducer source = img.getSource(); diff --git a/gnu/java/awt/peer/gtk/ComponentGraphics.java b/gnu/java/awt/peer/gtk/ComponentGraphics.java index 612efd628..763ad7dfd 100644 --- a/gnu/java/awt/peer/gtk/ComponentGraphics.java +++ b/gnu/java/awt/peer/gtk/ComponentGraphics.java @@ -468,6 +468,7 @@ public class ComponentGraphics extends CairoGraphics2D } BufferedImage bimg; + img = AsyncImage.realImage(img, observer); if (img instanceof BufferedImage) bimg = (BufferedImage) img; else diff --git a/gnu/java/awt/peer/gtk/GtkToolkit.java b/gnu/java/awt/peer/gtk/GtkToolkit.java index 26724206d..9b654f10e 100644 --- a/gnu/java/awt/peer/gtk/GtkToolkit.java +++ b/gnu/java/awt/peer/gtk/GtkToolkit.java @@ -189,7 +189,7 @@ public class GtkToolkit extends gnu.java.awt.ClasspathToolkit * Helper to return either a Image -- the argument -- or a * GtkImage with the errorLoading flag set if the argument is null. */ - private Image imageOrError(Image b) + static Image imageOrError(Image b) { if (b == null) return GtkImage.getErrorImage(); @@ -216,16 +216,7 @@ public class GtkToolkit extends gnu.java.awt.ClasspathToolkit public Image createImage (URL url) { - Image image; - try - { - image = CairoSurface.getBufferedImage( new GtkImage( url ) ); - } - catch (IllegalArgumentException iae) - { - image = null; - } - return imageOrError(image); + return new AsyncImage(url); } public Image createImage (ImageProducer producer) @@ -391,6 +382,13 @@ public class GtkToolkit extends gnu.java.awt.ClasspathToolkit return ((((GtkImage)image).checkImage (observer) & ImageObserver.ALLBITS) != 0); + if (image instanceof AsyncImage) + { + AsyncImage aImg = (AsyncImage) image; + aImg.addObserver(observer); + return aImg.realImage != null; + } + /* Assume anything else is too */ return true; } -- cgit v1.2.1