Source for javax.imageio.spi.ImageReaderWriterSpi

   1: /* ImageReaderWriterSpi.java -- Superclass for image reader and writer spis.
   2:    Copyright (C) 2004, 2005  Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.imageio.spi;
  40: 
  41: 
  42: /**
  43:  * An abstract superclass that contains the common parts of {@link
  44:  * javax.imageio.spi.ImageReaderSpi} and {@link
  45:  * javax.imageio.spi.ImageWriterSpi}.
  46:  *
  47:  * @since 1.4
  48:  *
  49:  * @author Sascha Brawer (brawer@dandelis.ch)
  50:  */
  51: public abstract class ImageReaderWriterSpi
  52:   extends IIOServiceProvider
  53: {
  54:   /**
  55:    * The human-readable, localized names of the supported image
  56:    * formats. This value should be non-<code>null</code> after
  57:    * construction.
  58:    *
  59:    * @see #getFormatNames()
  60:    */
  61:   protected String[] names;
  62: 
  63: 
  64:   /**
  65:    * The file suffixes of the supported image formats. This value
  66:    * should be non-<code>null</code> after construction.
  67:    *
  68:    * @see #getFileSuffixes()
  69:    */
  70:   protected String[] suffixes;
  71: 
  72: 
  73:   /**
  74:    * The MIME types of the supported image formats.  This value
  75:    * should be non-<code>null</code> after construction.
  76:    *
  77:    * @see #getMIMETypes()
  78:    */
  79:   protected String[] MIMETypes;
  80: 
  81: 
  82:   /**
  83:    * The fully qualified name of the class that implements the {@link
  84:    * javax.imageio.ImageReader} or {@link javax.imageio.ImageWriter}
  85:    * interface.  This value should be non-<code>null</code> after
  86:    * construction.
  87:    *
  88:    * @see #getPluginClassName()
  89:    */
  90:   protected String pluginClassName;
  91: 
  92: 
  93:   /**
  94:    * Indicates whether the per-stream {@linkplain
  95:    * javax.imageio.metadata.IIOMetadata metadata objects} associated
  96:    * with this plug-in support format
  97:    * <code>&#x201c;javax_imageio_1.0&#x201d;</code> in their
  98:    * <code>getAsTree</code> and <code>setAsTree</code> methods.
  99:    *
 100:    * @see #isStandardStreamMetadataFormatSupported()
 101:    */
 102:   protected boolean supportsStandardStreamMetadataFormat;
 103: 
 104: 
 105:   /**
 106:    * The name of the format that allows encoding all stream metadata
 107:    * without loss, or <code>null</code> if this plug-in does not
 108:    * provide a format that preserves all stream metadata.
 109:    */
 110:   protected String nativeStreamMetadataFormatName;
 111: 
 112:   protected String nativeStreamMetadataFormatClassName;
 113: 
 114: 
 115:   /**
 116:    * The names of additional formats for encoding stream metadata,
 117:    * other than the {@linkplain
 118:    * #isStandardStreamMetadataFormatSupported() standard} and the
 119:    * {@linkplain #getNativeStreamMetadataFormatName() native} formats,
 120:    * or <code>null</code> if this plug-in does not provide any extra
 121:    * formats.
 122:    */
 123:   protected String[] extraStreamMetadataFormatNames;
 124: 
 125: 
 126:   protected String[] extraStreamMetadataFormatClassNames;
 127: 
 128: 
 129:   /**
 130:    * Indicates whether the per-image {@linkplain
 131:    * javax.imageio.metadata.IIOMetadata metadata objects} associated
 132:    * with this plug-in support format
 133:    * <code>&#x201c;javax_imageio_1.0&#x201d;</code> in their
 134:    * <code>getAsTree</code> and <code>setAsTree</code> methods.
 135:    *
 136:    * @see #isStandardImageMetadataFormatSupported()
 137:    */
 138:   protected boolean supportsStandardImageMetadataFormat;
 139: 
 140: 
 141:   /**
 142:    * The name of the format that allows encoding all image metadata
 143:    * without loss, or <code>null</code> if this plug-in does not
 144:    * provide a format that preserves all image metadata.
 145:    */
 146:   protected String nativeImageMetadataFormatName;
 147: 
 148:   protected String nativeImageMetadataFormatClassName;
 149: 
 150: 
 151:   /**
 152:    * The names of additional formats for encoding image metadata,
 153:    * other than the {@linkplain
 154:    * #isStandardImageMetadataFormatSupported() standard} and the
 155:    * {@linkplain #getNativeImageMetadataFormatName() native} formats,
 156:    * or <code>null</code> if this plug-in does not provide any extra
 157:    * formats.
 158:    */
 159:   protected String[] extraImageMetadataFormatNames;
 160: 
 161: 
 162:   protected String[] extraImageMetadataFormatClassNames;
 163: 
 164: 
 165:   /**
 166:    * Constructs an <code>ImageReaderWriteSpi</code> instance, without
 167:    * specifying a number of parameters. Constructors of concrete
 168:    * subclasses must ensure that they set all inherited fields to
 169:    * meaningful values.
 170:    */
 171:   public ImageReaderWriterSpi()
 172:   {
 173:   }
 174: 
 175: 
 176:   /**
 177:    * Constructs an <code>ImageReaderWriteSpi</code> instance,
 178:    * specifying a number of parameters.
 179:    *
 180:    * @param names the human-readable, localized names of the supported
 181:    * image formats, for example <code>[&#x201c;Tagged Image File
 182:    * Format&#x201d;, &#x201c;Portable Network
 183:    * Graphics&#x201d;]</code>.
 184:    *
 185:    * @param suffixes the file suffixes of the supported image formats,
 186:    * for example <code>[&#x201c;tiff&#x201d;, &#x201c;tif&#x201d;,
 187:    * &#x201c;png&#x201d;]</code>.
 188:    *
 189:    * @param MIMETypes the MIME types of the supported image formats,
 190:    * for example <code>[&#x201c;image/tiff&#x201d;,
 191:    * &#x201c;image/png&#x201d;]</code>.
 192:    *
 193:    * @param pluginClassName the fully qualified name of the class that
 194:    * implements the {@link javax.imageio.ImageReader} or {@link
 195:    * javax.imageio.ImageWriter} interface.
 196:    *
 197:    * @param supportsStandardStreamMetadataFormat whether the
 198:    * per-stream {@linkplain javax.imageio.metadata.IIOMetadata
 199:    * metadata objects} associated with this plug-in support format
 200:    * <code>&#x201c;javax_imageio_1.0&#x201d;</code> in their
 201:    * <code>getAsTree</code> and <code>setAsTree</code> methods.
 202:    *
 203:    * @param nativeStreamMetadataFormatName the name of the format that
 204:    * allows encoding all stream metadata without loss, or
 205:    * <code>null</code> if this plug-in does not provide a format that
 206:    * preserves all stream metadata.
 207:    *
 208:    * @param extraStreamMetadataFormatNames the names of additional
 209:    * formats for encoding stream metadata, other than the {@linkplain
 210:    * #isStandardStreamMetadataFormatSupported() standard} and the
 211:    * {@linkplain #getNativeStreamMetadataFormatName() native} formats,
 212:    * or <code>null</code> if this plug-in does not provide any extra
 213:    * formats.
 214:    *
 215:    * @param supportsStandardImageMetadataFormat whether the per-image
 216:    * {@linkplain javax.imageio.metadata.IIOMetadata metadata objects}
 217:    * associated with this plug-in support format
 218:    * <code>&#x201c;javax_imageio_1.0&#x201d;</code> in their
 219:    * <code>getAsTree</code> and <code>setAsTree</code> methods.
 220:    *
 221:    * @param nativeImageMetadataFormatName the name of the format that
 222:    * allows encoding all image metadata without loss, or
 223:    * <code>null</code> if this plug-in does not provide a format that
 224:    * preserves all image metadata.
 225:    *
 226:    * @param extraImageMetadataFormatNames the names of additional
 227:    * formats for encoding image metadata, other than the {@linkplain
 228:    * #isStandardImageMetadataFormatSupported() standard} and the
 229:    * {@linkplain #getNativeImageMetadataFormatName() native} formats,
 230:    * or <code>null</code> if this plug-in does not provide any extra
 231:    * formats.
 232:    *
 233:    * @throws IllegalArgumentException if <code>vendorName</code>
 234:    * or <code>version</code> is <code>null</code>.
 235:    */
 236:   public ImageReaderWriterSpi(String vendorName, String version,
 237:                               String[] names, String[] suffixes,
 238:                               String[] MIMETypes, String pluginClassName,
 239:                               boolean supportsStandardStreamMetadataFormat,
 240:                               String nativeStreamMetadataFormatName,
 241:                               String nativeStreamMetadataFormatClassName,
 242:                               String[] extraStreamMetadataFormatNames,
 243:                               String[] extraStreamMetadataFormatClassNames,
 244:                               boolean supportsStandardImageMetadataFormat,
 245:                               String nativeImageMetadataFormatName,
 246:                               String nativeImageMetadataFormatClassName,
 247:                               String[] extraImageMetadataFormatNames,
 248:                               String[] extraImageMetadataFormatClassNames)
 249:   {
 250:     /* The inherited constructor will throw IllegalArgumentException
 251:      * if one of its arguments is null.
 252:      */
 253:     super(vendorName, version);
 254: 
 255:     if (names == null || names.length == 0 || pluginClassName == null)
 256:       throw new IllegalArgumentException();
 257: 
 258:     this.names = names;
 259:     this.suffixes = suffixes;
 260:     this.MIMETypes = MIMETypes;
 261:     this.pluginClassName = pluginClassName;
 262: 
 263:     this.supportsStandardStreamMetadataFormat
 264:       = supportsStandardStreamMetadataFormat;
 265: 
 266:     this.nativeStreamMetadataFormatName
 267:       = nativeStreamMetadataFormatName;
 268: 
 269:     this.nativeStreamMetadataFormatClassName
 270:       = nativeStreamMetadataFormatClassName;
 271: 
 272:     this.extraStreamMetadataFormatNames
 273:       = extraStreamMetadataFormatNames;
 274: 
 275:     this.extraStreamMetadataFormatClassNames
 276:       = extraStreamMetadataFormatClassNames;
 277: 
 278:     this.supportsStandardImageMetadataFormat
 279:       = supportsStandardImageMetadataFormat;
 280: 
 281:     this.nativeImageMetadataFormatName
 282:       = nativeImageMetadataFormatName;
 283: 
 284:     this.nativeImageMetadataFormatClassName
 285:       = nativeImageMetadataFormatClassName;
 286: 
 287:     this.extraImageMetadataFormatNames
 288:       = extraImageMetadataFormatNames;
 289: 
 290:     this.extraImageMetadataFormatClassNames
 291:       = extraImageMetadataFormatClassNames;
 292:   }
 293: 
 294: 
 295:   /**
 296:    * Returns the human-readable, localized names of the supported
 297:    * image formats. For example, a plug-in might return an array with
 298:    * the elements <code>[&#x201c;Tagged Image File Format&#x201d;,
 299:    * &#x201c;Portable Network Graphics&#x201d;]</code>.
 300:    */
 301:   public String[] getFormatNames()
 302:   {
 303:     return (String[]) names.clone();
 304:   }
 305: 
 306: 
 307:   /**
 308:    * Returns the file suffixes of the supported image formats, for
 309:    * example <code>[&#x201c;tiff&#x201d;, &#x201c;tif&#x201d;,
 310:    * &#x201c;png&#x201d;]</code>.
 311:    */
 312:   public String[] getFileSuffixes()
 313:   {
 314:     return suffixes;
 315:   }
 316: 
 317: 
 318:   /**
 319:    * Returns the MIME types of the supported image formats, for
 320:    * example <code>[&#x201c;image/tiff&#x201d;,
 321:    * &#x201c;image/png&#x201d;]</code>.
 322:    *
 323:    * @return an array of MIME type strings, or <code>null</code> if
 324:    * none of the supported formats has an associated MIME type.
 325:    */
 326:   public String[] getMIMETypes()
 327:   {
 328:     return MIMETypes;
 329:   }
 330: 
 331: 
 332:   /**
 333:    * Returns the fully qualified name of the class that implements the
 334:    * {@link javax.imageio.ImageReader} or {@link
 335:    * javax.imageio.ImageWriter} interface.
 336:    */
 337:   public String getPluginClassName()
 338:   {
 339:     return pluginClassName;
 340:   }
 341: 
 342: 
 343:   /**
 344:    * Returns whether the per-stream {@linkplain
 345:    * javax.imageio.metadata.IIOMetadata metadata objects} associated
 346:    * with this plug-in support format
 347:    * <code>&#x201c;javax_imageio_1.0&#x201d;</code> in their
 348:    * <code>getAsTree</code> and <code>setAsTree</code> methods.
 349:    */
 350:   public boolean isStandardStreamMetadataFormatSupported()
 351:   {
 352:     return supportsStandardStreamMetadataFormat;
 353:   }
 354: 
 355: 
 356:   /**
 357:    * Returns the name of the format that allows encoding all stream
 358:    * metadata without loss, or <code>null</code> if this plug-in does
 359:    * not provide a format that preserves all stream metadata.
 360:    *
 361:    * @see #getNativeImageMetadataFormatName()
 362:    */
 363:   public String getNativeStreamMetadataFormatName()
 364:   {
 365:     return nativeStreamMetadataFormatName;
 366:   }
 367: 
 368: 
 369:   /**
 370:    * Returns the names of additional formats for encoding stream
 371:    * metadata, other than the {@linkplain
 372:    * #isStandardStreamMetadataFormatSupported() standard} and the
 373:    * {@linkplain #getNativeStreamMetadataFormatName() native} formats,
 374:    * or <code>null</code> if this plug-in does not provide any extra
 375:    * formats.
 376:    *
 377:    * @see #getExtraImageMetadataFormatNames()
 378:    */
 379:   public String[] getExtraStreamMetadataFormatNames()
 380:   {
 381:     return extraStreamMetadataFormatNames;
 382:   }
 383: 
 384: 
 385:   /**
 386:    * Returns whether the per-image {@linkplain
 387:    * javax.imageio.metadata.IIOMetadata metadata objects} associated
 388:    * with this plug-in support format
 389:    * <code>&#x201c;javax_imageio_1.0&#x201d;</code> in their
 390:    * <code>getAsTree</code> and <code>setAsTree</code> methods.
 391:    */
 392:   public boolean isStandardImageMetadataFormatSupported()
 393:   {
 394:     return supportsStandardImageMetadataFormat;
 395:   }
 396: 
 397: 
 398:   /**
 399:    * Returns the name of the format that allows encoding all image
 400:    * metadata without loss, or <code>null</code> if this plug-in does
 401:    * not provide a format that preserves all image metadata.
 402:    *
 403:    * @see #getNativeStreamMetadataFormatName()
 404:    */
 405:   public String getNativeImageMetadataFormatName()
 406:   {
 407:     return nativeImageMetadataFormatName;
 408:   }
 409: 
 410: 
 411:   /**
 412:    * Returns the names of additional formats for encoding image
 413:    * metadata, other than the {@linkplain
 414:    * #isStandardImageMetadataFormatSupported() standard} and the
 415:    * {@linkplain #getNativeImageMetadataFormatName() native} formats,
 416:    * or <code>null</code> if this plug-in does not provide any extra
 417:    * formats.
 418:    *
 419:    * @see #getExtraStreamMetadataFormatNames()
 420:    */
 421:   public String[] getExtraImageMetadataFormatNames()
 422:   {
 423:     return extraImageMetadataFormatNames;
 424:   }
 425: }