/* ImageWriteParam.java --
   Copyright (C) 2004  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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 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 javax.imageio;

import java.awt.Dimension;
import java.util.Locale;

public class ImageWriteParam extends IIOParam
{
  public static final int MODE_DISABLED = 0;
  public static final int MODE_DEFAULT = 1;
  public static final int MODE_EXPLICIT = 2;
  public static final int MODE_COPY_FROM_METADATA = 3;
  
  protected boolean canOffsetTiles;
  protected boolean canWriteCompressed;
  protected boolean canWriteProgressive;
  protected boolean canWriteTiles;
  protected int compressionMode = MODE_COPY_FROM_METADATA;
  protected float compressionQuality;
  protected String compressionType;
  protected String[] compressionTypes;
  protected Locale locale;
  protected Dimension[] preferredTileSizes;
  protected int progressiveMode = MODE_COPY_FROM_METADATA;
  protected int tileGridXOffset;
  protected int tileGridYOffset;
  protected int tileHeight;
  protected int tileWidth;
  protected int tilingMode;
  protected boolean tilingSet;

  /**
   * Creates an empty <code>ImageWriteParam</code> object.
   * The subclass is responsible to initialize all fields.
   */
  protected ImageWriteParam()
  {
    // Do nothing here.
  }

  /**
   * Creates an <code>ImageWriteParam</code> object with the given locale.
   *
   * @param locale the locale to use for user visible strings
   */
  public ImageWriteParam(Locale locale)
  {
    this.locale = locale;
  }

  public float getBitRate(float quality)
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();

    return -1.0f;
  }

  private void checkSupportsCompression()
  {
    if (! canWriteCompressed())
      throw new UnsupportedOperationException("compression not supported");
  }

  private void checkNotExplicitCompression()
  {
    if (getCompressionMode() != MODE_EXPLICIT)
      throw new IllegalStateException("compression mode is not MODE_EXPLICIT");
  }
  
  private void checkCompressionTypesSet()
  {
    if (getCompressionType() == null
	&& getCompressionTypes() != null)
      throw new IllegalStateException("no compression type set");
  }

  private void checkSupportsProgressiveEncoding()
  {
    if (! canWriteProgressive())
      throw new UnsupportedOperationException
	("progressive output not supported");
  }
  
  private void checkSupportsTiling()
  {
    if (! canWriteTiles())
      throw new UnsupportedOperationException("tiling not supported");
  }

  private void checkNotExplicitTiling()
  {
    if (getTilingMode() != MODE_EXPLICIT)
      throw new IllegalStateException("tiling mode not MODE_EXPLICIT");
  }

  private void checkTilingInitialized()
  {
    if (! tilingSet)
      throw new IllegalStateException("tiling parameters not set");
  }

  private void checkMode(int mode)
  {
    if (mode < MODE_DISABLED || mode > MODE_COPY_FROM_METADATA)
      throw new IllegalArgumentException("mode not supported");
  }

  public boolean canOffsetTiles()
  {
    return canOffsetTiles;
  }

  public boolean canWriteCompressed()
  {
    return canWriteCompressed;
  }

  public boolean canWriteProgressive()
  {
    return canWriteProgressive;
  }

  public boolean canWriteTiles()
  {
    return canWriteTiles;
  }

  public int getCompressionMode()
  {
    checkSupportsCompression();

    return compressionMode;
  }

  public float getCompressionQuality()
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();

    return compressionQuality;
  }

  public String[] getCompressionQualityDescriptions()
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();;
    
    return null;
  }

  public float[] getCompressionQualityValues()
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();;
    
    return null;
  }

  public String getCompressionType()
  {
    checkNotExplicitCompression();

    return compressionType;
  }

  public String[] getCompressionTypes()
  {
    checkSupportsCompression();

    return compressionTypes != null ? (String[]) compressionTypes.clone() : null;
  }

  public Locale getLocale()
  {
    return locale;
  }

  public String getLocalizedCompressionTypeName()
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();

    return getCompressionType();
  }

  public Dimension[] getPreferredTileSizes()
  {
    checkSupportsTiling();

    return preferredTileSizes;
  }

  public int getProgressiveMode()
  {
    checkSupportsProgressiveEncoding();

    return progressiveMode;
  }

  public int getTileGridXOffset()
  {
    checkNotExplicitTiling();
    checkTilingInitialized();

    return tileGridXOffset;
  }

  public int getTileGridYOffset()
  {
    checkNotExplicitTiling();
    checkTilingInitialized();

    return tileGridYOffset;
  }

  public int getTileHeight()
  {
    checkNotExplicitTiling();
    checkTilingInitialized();

    return tileHeight;
  }

  public int getTileWidth()
  {
    checkNotExplicitTiling();
    checkTilingInitialized();

    return tileWidth;
  }

  public int getTilingMode()
  {
    checkSupportsTiling();

    return tilingMode;
  }

  public boolean isCompressionLossless()
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();

    return true;
  }

  public void setCompressionMode(int mode)
  {
    checkSupportsCompression();
    checkMode(mode);
    
    compressionMode = mode;
    
    if (mode == MODE_EXPLICIT)
      unsetCompression();
  }

  public void setCompressionQuality(float quality)
  {
    checkNotExplicitCompression();
    checkCompressionTypesSet();

    if (quality < 0.0f || quality > 1.0f)
      throw new IllegalArgumentException("quality out of range");

    compressionQuality = quality;
  }

  public void setCompressionType(String compressionType)
  {
    checkNotExplicitCompression();

    String[] types = getCompressionTypes();

    if (types == null)
      throw new UnsupportedOperationException("no settable compression types");
    
    if (compressionType == null)
      this.compressionType = null;

    for (int i = types.length - 1; i >= 0; --i)
      if (types[i].equals(compressionType))
	{
	  this.compressionType = compressionType;
	  return;
	}
    
    throw new IllegalArgumentException("unknown compression type");
  }

  public void setProgressiveMode(int mode)
  {
    checkSupportsProgressiveEncoding();
    checkMode(mode);
    
    progressiveMode = mode;
  }

  public void setTiling(int tileWidth, int tileHeight,
		        int tileGridXOffset, int tileGridYOffset)
  {
    checkNotExplicitTiling();

    if (! canOffsetTiles
	&& tileGridXOffset != 0
	&& tileGridYOffset != 0)
      throw new UnsupportedOperationException("tile offsets not supported");

    if (tileWidth < 0 || tileHeight < 0)
      throw new IllegalArgumentException("negative tile dimension");

    if (preferredTileSizes != null)
      {
	boolean found = false;

	for (int i = 0; i < preferredTileSizes.length; i += 2)
	  {
	    if (tileWidth >= preferredTileSizes[i].width
		&& tileWidth <= preferredTileSizes[i + 1].width
		&& tileHeight >= preferredTileSizes[i].height
		&& tileHeight <= preferredTileSizes[i + 1].height)
	      found = true;
	  }

	if (! found)
          throw new IllegalArgumentException("illegal tile size");
      }

    this.tilingSet = true;
    this.tileWidth = tileWidth;
    this.tileHeight = tileHeight;
    this.tileGridXOffset = tileGridXOffset;
    this.tileGridYOffset = tileGridYOffset;
  }

  public void setTilingMode(int mode)
  {
    checkSupportsTiling();
    checkMode(mode);
    tilingMode = mode;
  }

  public void unsetCompression()
  {
    checkNotExplicitCompression();
    
    compressionType = null;
    compressionQuality = 1.0F;
  }

  public void unsetTiling()
  {
    checkNotExplicitTiling();
    
    tileWidth = 0;
    tileHeight = 0;
    tileGridXOffset = 0;
    tileGridYOffset = 0;
  }
}