/* 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., 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 javax.imageio;

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

/**
 * DOCUMENT ME
 */
public class ImageWriteParam extends IIOParam
{

  /**
   * Can be passed to setTilingMode, setProgressiveMode and
   * setCompressionMode to disable feature.
   */
  public static final int MODE_DISABLED = 0;

  /**
   * Can be passed to setTilingMode, setProgressiveMode and
   * setCompressionMode to enable feature.
   */
  public static final int MODE_DEFAULT = 1;

  /**
   * Can be passed to setTilingMode, setCompressionMode to disable feature.
   */
  public static final int MODE_EXPLICIT = 2;

  /**
   * Can be passed to setTilingMode, setProgressiveMode and
   * setCompressionMode to enable feature.
   */
  public static final int MODE_COPY_FROM_METADATA = 3;

  /**
   * True if tiling grid offset parameters can be set.
   */
  protected boolean canOffsetTiles;

  /**
   * True if this writer can write images using compression.
   */
  protected boolean canWriteCompressed;

  /**
   * True if images can be written as a progressive sequence
   * of increasing quality.
   */
  protected boolean canWriteProgressive;

  /**
   * True if tile width and height parameters can be set.
   */
  protected boolean canWriteTiles;

  /**
   * Controls compression settings, which must be set to one of the four
   * MODE_* values.
   */
  protected int compressionMode = MODE_COPY_FROM_METADATA;

  /**
   * Contains the current compression quality setting.
   */
  protected float compressionQuality;

  /**
   * Contains the name of the current compression type.
   */
  protected String compressionType;

  /**
   * Array of the names of the available compression types.
   */
  protected String[] compressionTypes;

  /**
   * Localizes compression type names and quality descriptions,
   * or null to use default Locale.
   */
  protected Locale locale;

  /**
   * Preferred tile size range pairs.
   */
  protected Dimension[] preferredTileSizes;

  /**
   * The mode controlling progressive encoding, which must
   * be set to one of the four MODE_* values, except
   * MODE_EXPLICIT.
   */
  protected int progressiveMode = MODE_COPY_FROM_METADATA;

  /**
   * The amount by which the tile grid origin should be offset
   * horizontally from the image origin if tiling has been set.
   */
  protected int tileGridXOffset;

  /**
   * The amount by which the tile grid origin should be offset
   * vertically from the image origin if tiling has been set.
   */
  protected int tileGridYOffset;

  /**
   * The height of each tile if tiling has been set.
   */
  protected int tileHeight;

  /**
   * The width of each tile if tiling has been set.
   */
  protected int tileWidth;

  /**
   * The mode controlling tiling settings, which must be
   * set to one of the four MODE_* values.
   */
  protected int tilingMode;

  /**
   * True if the tiling parameters have been specified.
   */
  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;
  }
}