libjava/javax/imageio/ImageWriteParam.java

   1 /* ImageWriteParam.java --
   2    Copyright (C) 2004  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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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;
  40
  41 import java.awt.Dimension;
  42 import java.util.Locale;
  43
  44 public class ImageWriteParam extends IIOParam
  45 {
  46   public static final int MODE_DISABLED = 0;
  47   public static final int MODE_DEFAULT = 1;
  48   public static final int MODE_EXPLICIT = 2;
  49   public static final int MODE_COPY_FROM_METADATA = 3;
  50
  51   protected boolean canOffsetTiles;
  52   protected boolean canWriteCompressed;
  53   protected boolean canWriteProgressive;
  54   protected boolean canWriteTiles;
  55   protected int compressionMode = MODE_COPY_FROM_METADATA;
  56   protected float compressionQuality;
  57   protected String compressionType;
  58   protected String[] compressionTypes;
  59   protected Locale locale;
  60   protected Dimension[] preferredTileSizes;
  61   protected int progressiveMode = MODE_COPY_FROM_METADATA;
  62   protected int tileGridXOffset;
  63   protected int tileGridYOffset;
  64   protected int tileHeight;
  65   protected int tileWidth;
  66   protected int tilingMode;
  67   protected boolean tilingSet;
  68
  69   /**
  70    * Creates an empty <code>ImageWriteParam</code> object.
  71    * The subclass is responsible to initialize all fields.
  72    */
  73   protected ImageWriteParam()
  74   {
  75     // Do nothing here.
  76   }
  77
  78   /**
  79    * Creates an <code>ImageWriteParam</code> object with the given locale.
  80    *
  81    * @param locale the locale to use for user visible strings
  82    */
  83   public ImageWriteParam(Locale locale)
  84   {
  85     this.locale = locale;
  86   }
  87
  88   public float getBitRate(float quality)
  89   {
  90     checkNotExplicitCompression();
  91     checkCompressionTypesSet();
  92
  93     return -1.0f;
  94   }
  95
  96   private void checkSupportsCompression()
  97   {
  98     if (! canWriteCompressed())
  99       throw new UnsupportedOperationException("compression not supported");
 100   }
 101
 102   private void checkNotExplicitCompression()
 103   {
 104     if (getCompressionMode() != MODE_EXPLICIT)
 105       throw new IllegalStateException("compression mode is not MODE_EXPLICIT");
 106   }
 107
 108   private void checkCompressionTypesSet()
 109   {
 110     if (getCompressionType() == null
 111         && getCompressionTypes() != null)
 112       throw new IllegalStateException("no compression type set");
 113   }
 114
 115   private void checkSupportsProgressiveEncoding()
 116   {
 117     if (! canWriteProgressive())
 118       throw new UnsupportedOperationException
 119         ("progressive output not supported");
 120   }
 121
 122   private void checkSupportsTiling()
 123   {
 124     if (! canWriteTiles())
 125       throw new UnsupportedOperationException("tiling not supported");
 126   }
 127
 128   private void checkNotExplicitTiling()
 129   {
 130     if (getTilingMode() != MODE_EXPLICIT)
 131       throw new IllegalStateException("tiling mode not MODE_EXPLICIT");
 132   }
 133
 134   private void checkTilingInitialized()
 135   {
 136     if (! tilingSet)
 137       throw new IllegalStateException("tiling parameters not set");
 138   }
 139
 140   private void checkMode(int mode)
 141   {
 142     if (mode < MODE_DISABLED || mode > MODE_COPY_FROM_METADATA)
 143       throw new IllegalArgumentException("mode not supported");
 144   }
 145
 146   public boolean canOffsetTiles()
 147   {
 148     return canOffsetTiles;
 149   }
 150
 151   public boolean canWriteCompressed()
 152   {
 153     return canWriteCompressed;
 154   }
 155
 156   public boolean canWriteProgressive()
 157   {
 158     return canWriteProgressive;
 159   }
 160
 161   public boolean canWriteTiles()
 162   {
 163     return canWriteTiles;
 164   }
 165
 166   public int getCompressionMode()
 167   {
 168     checkSupportsCompression();
 169
 170     return compressionMode;
 171   }
 172
 173   public float getCompressionQuality()
 174   {
 175     checkNotExplicitCompression();
 176     checkCompressionTypesSet();
 177
 178     return compressionQuality;
 179   }
 180
 181   public String[] getCompressionQualityDescriptions()
 182   {
 183     checkNotExplicitCompression();
 184     checkCompressionTypesSet();;
 185
 186     return null;
 187   }
 188
 189   public float[] getCompressionQualityValues()
 190   {
 191     checkNotExplicitCompression();
 192     checkCompressionTypesSet();;
 193
 194     return null;
 195   }
 196
 197   public String getCompressionType()
 198   {
 199     checkNotExplicitCompression();
 200
 201     return compressionType;
 202   }
 203
 204   public String[] getCompressionTypes()
 205   {
 206     checkSupportsCompression();
 207
 208     return compressionTypes != null ? (String[]) compressionTypes.clone() : null;
 209   }
 210
 211   public Locale getLocale()
 212   {
 213     return locale;
 214   }
 215
 216   public String getLocalizedCompressionTypeName()
 217   {
 218     checkNotExplicitCompression();
 219     checkCompressionTypesSet();
 220
 221     return getCompressionType();
 222   }
 223
 224   public Dimension[] getPreferredTileSizes()
 225   {
 226     checkSupportsTiling();
 227
 228     return preferredTileSizes;
 229   }
 230
 231   public int getProgressiveMode()
 232   {
 233     checkSupportsProgressiveEncoding();
 234
 235     return progressiveMode;
 236   }
 237
 238   public int getTileGridXOffset()
 239   {
 240     checkNotExplicitTiling();
 241     checkTilingInitialized();
 242
 243     return tileGridXOffset;
 244   }
 245
 246   public int getTileGridYOffset()
 247   {
 248     checkNotExplicitTiling();
 249     checkTilingInitialized();
 250
 251     return tileGridYOffset;
 252   }
 253
 254   public int getTileHeight()
 255   {
 256     checkNotExplicitTiling();
 257     checkTilingInitialized();
 258
 259     return tileHeight;
 260   }
 261
 262   public int getTileWidth()
 263   {
 264     checkNotExplicitTiling();
 265     checkTilingInitialized();
 266
 267     return tileWidth;
 268   }
 269
 270   public int getTilingMode()
 271   {
 272     checkSupportsTiling();
 273
 274     return tilingMode;
 275   }
 276
 277   public boolean isCompressionLossless()
 278   {
 279     checkNotExplicitCompression();
 280     checkCompressionTypesSet();
 281
 282     return true;
 283   }
 284
 285   public void setCompressionMode(int mode)
 286   {
 287     checkSupportsCompression();
 288     checkMode(mode);
 289
 290     compressionMode = mode;
 291
 292     if (mode == MODE_EXPLICIT)
 293       unsetCompression();
 294   }
 295
 296   public void setCompressionQuality(float quality)
 297   {
 298     checkNotExplicitCompression();
 299     checkCompressionTypesSet();
 300
 301     if (quality < 0.0f || quality > 1.0f)
 302       throw new IllegalArgumentException("quality out of range");
 303
 304     compressionQuality = quality;
 305   }
 306
 307   public void setCompressionType(String compressionType)
 308   {
 309     checkNotExplicitCompression();
 310
 311     String[] types = getCompressionTypes();
 312
 313     if (types == null)
 314       throw new UnsupportedOperationException("no settable compression types");
 315
 316     if (compressionType == null)
 317       this.compressionType = null;
 318
 319     for (int i = types.length - 1; i >= 0; --i)
 320       if (types[i].equals(compressionType))
 321         {
 322           this.compressionType = compressionType;
 323           return;
 324         }
 325
 326     throw new IllegalArgumentException("unknown compression type");
 327   }
 328
 329   public void setProgressiveMode(int mode)
 330   {
 331     checkSupportsProgressiveEncoding();
 332     checkMode(mode);
 333
 334     progressiveMode = mode;
 335   }
 336
 337   public void setTiling(int tileWidth, int tileHeight,
 338                         int tileGridXOffset, int tileGridYOffset)
 339   {
 340     checkNotExplicitTiling();
 341
 342     if (! canOffsetTiles
 343         && tileGridXOffset != 0
 344         && tileGridYOffset != 0)
 345       throw new UnsupportedOperationException("tile offsets not supported");
 346
 347     if (tileWidth < 0 || tileHeight < 0)
 348       throw new IllegalArgumentException("negative tile dimension");
 349
 350     if (preferredTileSizes != null)
 351       {
 352         boolean found = false;
 353
 354         for (int i = 0; i < preferredTileSizes.length; i += 2)
 355           {
 356             if (tileWidth >= preferredTileSizes[i].width
 357                 && tileWidth <= preferredTileSizes[i + 1].width
 358                 && tileHeight >= preferredTileSizes[i].height
 359                 && tileHeight <= preferredTileSizes[i + 1].height)
 360               found = true;
 361           }
 362
 363         if (! found)
 364           throw new IllegalArgumentException("illegal tile size");
 365       }
 366
 367     this.tilingSet = true;
 368     this.tileWidth = tileWidth;
 369     this.tileHeight = tileHeight;
 370     this.tileGridXOffset = tileGridXOffset;
 371     this.tileGridYOffset = tileGridYOffset;
 372   }
 373
 374   public void setTilingMode(int mode)
 375   {
 376     checkSupportsTiling();
 377     checkMode(mode);
 378     tilingMode = mode;
 379   }
 380
 381   public void unsetCompression()
 382   {
 383     checkNotExplicitCompression();
 384
 385     compressionType = null;
 386     compressionQuality = 1.0F;
 387   }
 388
 389   public void unsetTiling()
 390   {
 391     checkNotExplicitTiling();
 392
 393     tileWidth = 0;
 394     tileHeight = 0;
 395     tileGridXOffset = 0;
 396     tileGridYOffset = 0;
 397   }
 398 }