2004-10-05 Michael Koch <konqueror@gmx.de>

	* javax/imageio/ImageReader.java,
	javax/imageio/ImageWriter.java,
	javax/imageio/spi/ImageWriterSpi.java:
	Add SOME new methods.

3 files changed, 261 insertions, 0 deletions

diff --git a/javax/imageio/ImageReader.java b/javax/imageio/ImageReader.java
index fb81046f0..91cb53cd8 100644
--- a/javax/imageio/ImageReader.java
+++ b/javax/imageio/ImageReader.java
@@ -54,6 +54,8 @@ import javax.imageio.spi.ImageReaderSpi;
 
 public abstract class ImageReader
 {
+  private boolean aborted;
+  
   protected Locale[] availableLocales;
   protected boolean ignoreMetadata;
   protected Object input;
@@ -71,6 +73,15 @@ public abstract class ImageReader
     this.originatingProvider = originatingProvider;
   }
 
+  public void abort()
+  {
+    aborted = true;
+  }
+
+  protected boolean abortRequested()
+  {
+    return aborted;
+  }
 
   public void addIIOReadProgressListener(IIOReadProgressListener listener)
   {
@@ -101,6 +112,11 @@ public abstract class ImageReader
     return false;
   }
 
+  protected void clearAbortRequest()
+  {
+    aborted = false;
+  }
+  
   public void dispose()
   {
     // The default implementation does nothing.
@@ -167,6 +183,18 @@ public abstract class ImageReader
   public abstract IIOMetadata getStreamMetadata()
     throws IOException;
 
+  public int getThumbnailHeight(int imageIndex, int thumbnailIndex)
+    throws IOException
+  {
+    return readThumbnail(imageIndex, thumbnailIndex).getHeight();
+  }
+
+  public int getThumbnailWidth(int imageIndex, int thumbnailIndex)
+    throws IOException
+  {
+    return readThumbnail(imageIndex, thumbnailIndex).getWidth();
+  }
+
   public int getTileGridXOffset(int imageIndex)
     throws IOException
   {
diff --git a/javax/imageio/ImageWriter.java b/javax/imageio/ImageWriter.java
index 703e866da..b12431e3e 100644
--- a/javax/imageio/ImageWriter.java
+++ b/javax/imageio/ImageWriter.java
@@ -38,6 +38,8 @@ exception statement from your version. */
 
 package javax.imageio;
 
+import java.awt.Dimension;
+import java.io.IOException;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
@@ -51,6 +53,8 @@ import javax.imageio.spi.ImageWriterSpi;
 public abstract class ImageWriter
   implements ImageTranscoder
 {
+  private boolean aborted;
+  
   protected Locale[] availableLocales;
   protected Locale locale;
   protected ImageWriterSpi originatingProvider;
@@ -64,6 +68,22 @@ public abstract class ImageWriter
     this.originatingProvider = originatingProvider;
   }
 
+  private void checkOutputSet()
+  {
+    if (output == null)
+      throw new IllegalStateException("no output set");
+  }
+  
+  public void abort()
+  {
+    aborted = true;
+  }
+
+  protected boolean abortRequested()
+  {
+    return aborted;
+  }
+
   public void addIIOWriteProgressListener(IIOWriteProgressListener listener)
   {
     if (listener == null)
@@ -80,6 +100,75 @@ public abstract class ImageWriter
     warningListeners.add(listener);
   }
 
+  public boolean canInsertEmpty(int imageIndex)
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canInsertImage(int imageIndex)
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canRemoveImage(int imageIndex)
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canReplaceImageMetadata(int imageIndex)
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canReplacePixels(int imageIndex)
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canReplaceStreamMetadata()
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canWriteEmpty()
+    throws IOException
+  {
+    checkOutputSet();
+    return false;
+  }
+
+  public boolean canWriteRasters()
+  {
+    return false;
+  }
+
+  public boolean canWriteSequence()
+  {
+    return false;
+  }
+
+  protected void clearAbortRequest()
+  {
+    aborted = false;
+  }
+  
+  public void dispose()
+  {
+    // The default implementation is empty. Subclasses have to overwrite it.
+  }
+  
   public Locale[] getAvailableLocales()
   {
     return availableLocales;
@@ -89,16 +178,40 @@ public abstract class ImageWriter
 
   public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param);
 
+  public ImageWriteParam getDefaultWriteParam()
+  {
+    return new ImageWriteParam(getLocale());
+  }
+
   public Locale getLocale()
   {
     return locale;
   }
 
+  public int getNumThumbnailsSupported (ImageTypeSpecifier imageType, ImageWriteParam param,
+		                        IIOMetadata streamMetadata, IIOMetadata imageMetadata)
+  {
+    return 0;
+  }
+
   public ImageWriterSpi getOriginatingProvider()
   {
     return originatingProvider;
   }
 
+  public Object getOutput()
+  {
+    return output;
+  }
+
+  public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType,
+		                                 ImageWriteParam param,
+						 IIOMetadata streamMetadata,
+						 IIOMetadata imageMetadata)
+  {
+    return null;
+  }
+
   protected void processImageComplete()
   {
     Iterator it = progressListeners.iterator();
@@ -212,4 +325,55 @@ public abstract class ImageWriter
     
     warningListeners.remove(listener);
   }
+  
+  public void reset()
+  {
+    setOutput(null);
+    setLocale(null);
+    removeAllIIOWriteWarningListeners();
+    removeAllIIOWriteProgressListeners();
+    clearAbortRequest();
+  }
+  
+  public void setLocale(Locale locale)
+  {
+    if (locale != null)
+      {
+	// Check if its a valid locale.
+	boolean found = false;
+
+	if (availableLocales != null)
+	  for (int i = availableLocales.length - 1; i >= 0; --i)
+	    if (availableLocales[i].equals(locale))
+	      found = true;
+
+	if (! found)
+	  throw new IllegalArgumentException("looale not available");
+      }
+
+    this.locale = locale;
+  }
+
+  public void setOutput(Object output)
+  {
+    if (output != null)
+      {
+	// Check if its a valid output object.
+	boolean found = false;
+	Class[] types = null;
+
+	if (originatingProvider != null)
+	  types = originatingProvider.getOutputTypes();
+	
+	if (types != null)
+	  for (int i = types.length - 1; i >= 0; --i)
+	    if (types[i].equals(output.getClass()))
+	      found = true;
+
+	if (! found)
+	  throw new IllegalArgumentException("output type not available");
+      }
+
+    this.output = output;
+  }
 }
diff --git a/javax/imageio/spi/ImageWriterSpi.java b/javax/imageio/spi/ImageWriterSpi.java
index 476e032bc..844d9ee41 100644
--- a/javax/imageio/spi/ImageWriterSpi.java
+++ b/javax/imageio/spi/ImageWriterSpi.java
@@ -38,6 +38,11 @@ exception statement from your version. */
 
 package javax.imageio.spi;
 
+import java.awt.image.RenderedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriter;
 import javax.imageio.stream.ImageOutputStream;
 
 /**
@@ -55,4 +60,68 @@ public abstract class ImageWriterSpi extends ImageReaderWriterSpi
   {
     // Do nothing here.
   }
+
+  public ImageWriterSpi(String vendorName, String version, String[] names,
+                        String[] suffixes, String[] MIMETypes,
+                        String writerClassName, Class[] outputTypes,
+                        String[] readerSpiNames,
+                        boolean supportsStandardStreamMetadataFormat,
+                        String nativeStreamMetadataFormatName,
+                        String nativeStreamMetadataFormatClassName,
+                        String[] extraStreamMetadataFormatNames,
+                        String[] extraStreamMetadataFormatClassNames,
+                        boolean supportsStandardImageMetadataFormat,
+                        String nativeImageMetadataFormatName,
+                        String nativeImageMetadataFormatClassName,
+                        String[] extraImageMetadataFormatNames,
+                        String[] extraImageMetadataFormatClassNames)
+  {
+    super(vendorName, version, names, suffixes, MIMETypes, writerClassName,
+          supportsStandardStreamMetadataFormat, nativeStreamMetadataFormatName,
+          nativeStreamMetadataFormatClassName, extraStreamMetadataFormatNames,
+          extraStreamMetadataFormatClassNames, supportsStandardImageMetadataFormat,
+          nativeImageMetadataFormatName, nativeImageMetadataFormatClassName,
+          extraImageMetadataFormatNames, extraImageMetadataFormatClassNames);
+
+    if (writerClassName == null)
+      throw new IllegalArgumentException("writerClassName is null");
+
+    if (outputTypes == null
+        || outputTypes.length == 0)
+      throw new IllegalArgumentException("outputTypes may not be null or empty");
+    
+    this.outputTypes = outputTypes;
+    this.readerSpiNames = readerSpiNames;    
+  }
+
+  public abstract boolean canEncodeImage(ImageTypeSpecifier type);
+
+  public boolean canEncodeImage(RenderedImage image)
+  {
+    return canEncodeImage (new ImageTypeSpecifier(image));
+  }
+
+  public ImageWriter createWriterInstance()
+    throws IOException
+  {
+    return createWriterInstance(null);
+  }
+
+  public abstract ImageWriter createWriterInstance(Object extension)
+    throws IOException;
+
+  public String[] getImageReaderSpiNames()
+  {
+    return readerSpiNames;
+  }
+
+  public Class[] getOutputTypes()
+  {
+    return outputTypes;
+  }
+
+  public boolean isFormatLossless()
+  {
+    return true;
+  }
 }