obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 495 insertions, 0 deletions

diff --git a/libjava/classpath/javax/imageio/ImageWriteParam.java b/libjava/classpath/javax/imageio/ImageWriteParam.java
new file mode 100644
index 000000000..1c400e1ea
--- /dev/null
+++ b/libjava/classpath/javax/imageio/ImageWriteParam.java
@@ -0,0 +1,495 @@
+/* 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;
+  }
+}