libjava/classpath/java/awt/Image.java

   1 /* Image.java -- superclass for images
   2    Copyright (C) 1999, 2002, 2004, 2005, 2006  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 java.awt;
  40
  41 import java.awt.image.AreaAveragingScaleFilter;
  42 import java.awt.image.FilteredImageSource;
  43 import java.awt.image.ImageFilter;
  44 import java.awt.image.ImageObserver;
  45 import java.awt.image.ImageProducer;
  46 import java.awt.image.ReplicateScaleFilter;
  47
  48 /**
  49  * This is the abstract superclass of all image objects in Java.
  50  *
  51  * @author Aaron M. Renn (arenn@urbanophile.com)
  52  * @since 1.0
  53  * @status updated to 1.5
  54  */
  55 public abstract class Image
  56 {
  57   /**
  58    * This variable is returned whenever a property that is not defined
  59    * is requested.
  60    */
  61   // For debug purposes, this might as well be a unique string.
  62   public static final Object UndefinedProperty
  63     = new String("undefined property");
  64
  65   /**
  66    * Constant indicating that the default scaling algorithm should be used.
  67    *
  68    * @since 1.1
  69    */
  70   public static final int SCALE_DEFAULT = 1;
  71
  72   /**
  73    * Constant indicating that a fast scaling algorithm should be used.
  74    *
  75    * @since 1.1
  76    */
  77   public static final int SCALE_FAST = 2;
  78
  79   /**
  80    * Constant indicating that a smooth scaling algorithm should be used.
  81    *
  82    * @since 1.1
  83    */
  84   public static final int SCALE_SMOOTH = 4;
  85
  86   /**
  87    * Constant indicating that the <code>ReplicateScaleFilter</code> class
  88    * algorithm should be used for scaling.
  89    *
  90    * @see ReplicateScaleFilter
  91    * @since 1.1
  92    */
  93   public static final int SCALE_REPLICATE = 8;
  94
  95   /**
  96    * Constant indicating that the area averaging scaling algorithm should be
  97    * used.
  98    *
  99    * @see java.awt.image.AreaAveragingScaleFilter
 100    * @since 1.1
 101    */
 102   public static final int SCALE_AREA_AVERAGING = 16;
 103
 104   /**
 105    * The acceleration priority of the image
 106    * @since 1.5
 107    */
 108   protected float accelerationPriority;
 109
 110   /**
 111    * A default constructor for subclasses.
 112    */
 113   public Image()
 114   {
 115   }
 116
 117   /**
 118    * Returns the width of the image, or -1 if it is unknown.  If the
 119    * image width is unknown, the observer object will be notified when
 120    * the value is known.
 121    *
 122    * @param observer the image observer for this object
 123    * @return the width in pixels
 124    * @see #getHeight(ImageObserver)
 125    */
 126   public abstract int getWidth(ImageObserver observer);
 127
 128   /**
 129    * Returns the height of the image, or -1 if it is unknown.  If the
 130    * image height is unknown, the observer object will be notified when
 131    * the value is known.
 132    *
 133    * @param observer the image observer for this object
 134    * @return the height in pixels
 135    * @see #getWidth(ImageObserver)
 136    */
 137   public abstract int getHeight(ImageObserver observer);
 138
 139   /**
 140    * Returns the image producer object for this object. The producer is the
 141    * object which generates pixels for this image.
 142    *
 143    * @return the image producer for this object
 144    */
 145   public abstract ImageProducer getSource();
 146
 147   /**
 148    * Returns a graphics context object for drawing an off-screen object.
 149    * This method is only valid for off-screen objects.
 150    *
 151    * @return a graphics context object for an off-screen object
 152    */
 153   public abstract Graphics getGraphics();
 154
 155   /**
 156    * This method requests a named property for an object.  The value of the
 157    * property is returned. The value <code>UndefinedProperty</code> is
 158    * returned if there is no property with the specified name.  The value
 159    * <code>null</code> is returned if the properties for the object are
 160    * not yet known.  In this case, the specified image observer is notified
 161    * when the properties are known.
 162    *
 163    * @param name the requested property name
 164    * @param observer the image observer for this object
 165    * @return the named property, if available
 166    * @see #UndefinedProperty
 167    */
 168   public abstract Object getProperty(String name, ImageObserver observer);
 169
 170   /**
 171    * Scales the image to the requested dimension. A new Image with asynchronous
 172    * loading will be produced according to the hints of the algorithm
 173    * requested. If either the width or height is non-positive, it is adjusted
 174    * to preserve the original aspect ratio.
 175    * If an illegal value of <code>flags</code> is passed,
 176    * the default algorithm is used.
 177    *
 178    * @param width the width of the scaled image
 179    * @param height the height of the scaled image
 180    * @param flags a value indicating the algorithm to use
 181    * @return the scaled <code>Image</code> object
 182    * @see #SCALE_DEFAULT
 183    * @see #SCALE_FAST
 184    * @see #SCALE_SMOOTH
 185    * @see #SCALE_REPLICATE
 186    * @see #SCALE_AREA_AVERAGING
 187    * @since 1.1
 188    */
 189   public Image getScaledInstance(int width, int height, int flags)
 190   {
 191     ImageFilter filter;
 192     switch (flags)
 193     {
 194       case SCALE_AREA_AVERAGING:
 195       case SCALE_SMOOTH:
 196         filter = new AreaAveragingScaleFilter(width, height);
 197         break;
 198       case SCALE_DEFAULT:
 199       case SCALE_FAST:
 200       case SCALE_REPLICATE:
 201       default:
 202         filter = new ReplicateScaleFilter(width, height);
 203     }
 204
 205     ImageProducer producer = new FilteredImageSource(getSource(), filter);
 206     return Toolkit.getDefaultToolkit().createImage(producer);
 207   }
 208
 209   /**
 210    * Flushes (that is, destroys) any resources used for this image.  This
 211    * includes the actual image data.
 212    */
 213   public abstract void flush();
 214
 215   /**
 216    * Sets the acceleration priority of the image.
 217    * This is a value from 0 (lowest) to 1 (highest), which may
 218    * be used as a hint for image acceleration.
 219    * E.g. higher priority images may be stored in video memory.
 220    * @param priority - the priority
 221    * @throws IllegalArgumentException if priority is not >= 0 and <= 1.
 222    *
 223    * @since 1.5
 224    */
 225   public void setAccelerationPriority(float priority)
 226   {
 227     if( priority < 0f || priority > 1f)
 228       throw new IllegalArgumentException("Invalid priority value.");
 229     accelerationPriority = priority;
 230   }
 231
 232   /**
 233    * Returns the acceleration priority of the image.
 234    *
 235    * @see #setAccelerationPriority(float)
 236    * @since 1.5
 237    */
 238   public float getAccelerationPriority()
 239   {
 240     return accelerationPriority;
 241   }
 242 } // class Image