gtkimage.java

linux下建立JAVA虚拟机的源码KAFFE

  private GtkImage (GtkImage src, int width, int height, int hints)
  {
    this.width = width;
    this.height = height;
    props = new Hashtable();
    isLoaded = true;
    observers = null;
    offScreen = false;

    // Use the GDK scaling method.
    synchronized(GdkPixbufDecoder.pixbufLock)
      {
	createScaledPixmap(src, hints);
      }
  }

  /**
   * Package private constructor to create a GtkImage from a given
   * PixBuf pointer.
   */
  GtkImage (Pointer pixbuf)
  {
    pixmap = pixbuf;
    synchronized(GdkPixbufDecoder.pixbufLock)
      {
	createFromPixbuf();
      }
    isLoaded = true;
    observers = null;
    offScreen = false;
    props = new Hashtable();
  }

  // The singleton GtkImage that is returned on errors by GtkToolkit.
  private static GtkImage errorImage;

  /**
   * Returns an empty GtkImage with the errorLoading flag set.
   * Called from GtkToolKit when some error occured, but an image needs
   * to be returned anyway.
   */
  static synchronized GtkImage getErrorImage()
  {
    if (errorImage == null)
      {
	errorImage = new GtkImage();
	errorImage.errorLoading = true;
      }
    return errorImage;
  }

  /**
   * Native helper function for constructor that takes a pixbuf Pointer.
   * Should be called with the GdkPixbufDecoder.pixbufLock held.
   */
  private native void createFromPixbuf();

  /**
   * Callback from the image consumer.
   */
  public void setImage(int width, int height, 
		       int[] pixels, Hashtable properties)
  {
    this.width = width;
    this.height = height;
    props = (properties != null) ? properties : new Hashtable();

    if (width <= 0 || height <= 0 || pixels == null)
      {
	errorLoading = true;
	return;
      }

    isLoaded = true;
    deliver();
    synchronized(GdkPixbufDecoder.pixbufLock)
      {
	createPixmap();
	setPixels(pixels);
      }
  }

  // java.awt.Image methods ////////////////////////////////////////////////

  public synchronized int getWidth (ImageObserver observer)
  {
    if (addObserver(observer))
      return -1;

    return width;
  }
  
  public synchronized int getHeight (ImageObserver observer)
  {
    if (addObserver(observer))
      return -1;
    
    return height;
  }

  public synchronized Object getProperty (String name, ImageObserver observer)
  {
    if (addObserver(observer))
      return UndefinedProperty;
    
    Object value = props.get (name);
    return (value == null) ? UndefinedProperty : value;
  }

  /**
   * Returns the source of this image.
   */
  public ImageProducer getSource ()
  {
    if (!isLoaded)
      return null;

    int[] pixels;
    synchronized(GdkPixbufDecoder.pixbufLock)
      {
	pixels = getPixels();
      }
    return new MemoryImageSource(width, height, nativeModel, pixels, 
				 0, width);
  }

  /**
   * Creates a GdkGraphics context for this pixmap.
   */
  public Graphics getGraphics ()
  {
    if (!isLoaded) 
      return null;
    if (offScreen)
      return new GdkGraphics(this);
    else
      throw new IllegalAccessError("This method only works for off-screen"
				   +" Images.");
  }
  
  /**
   * Returns a scaled instance of this pixmap.
   */
  public Image getScaledInstance(int width,
				 int height,
				 int hints)
  {
    if (width <= 0 || height <= 0)
      throw new IllegalArgumentException("Width and height of scaled bitmap"+
					 "must be >= 0");

    return new GtkImage(this, width, height, hints);
  }

  /**
   * If the image is loaded and comes from an ImageProducer, 
   * regenerate the image from there.
   *
   * I have no idea if this is ever actually used. Since GtkImage can't be
   * instantiated directly, how is the user to know if it was created from
   * an ImageProducer or not?
   */
  public synchronized void flush ()
  {
    if (isLoaded && source != null)
      {
	observers = new Vector();
	isLoaded = false;
	synchronized(GdkPixbufDecoder.pixbufLock)
	  {
	    freePixmap();
	  }
	source.startProduction(new GtkImageConsumer(this, source));
      }
  }

  public void finalize()
  {
    if (isLoaded)
      {
	synchronized(GdkPixbufDecoder.pixbufLock)
	  {
	    freePixmap();
	  }
      }
  }

  /**
   * Returns the image status, used by GtkToolkit
   */
  public int checkImage (ImageObserver observer)
  {
    if (addObserver(observer))
      {
	if (errorLoading == true)
	  return ImageObserver.ERROR;
	else
	  return 0;
      }

    return ImageObserver.ALLBITS | ImageObserver.WIDTH | ImageObserver.HEIGHT;
  }

  // Drawing methods ////////////////////////////////////////////////

  /**
   * Draws an image with eventual scaling/transforming.
   */
  public boolean drawImage (GdkGraphics g, int dx1, int dy1, int dx2, int dy2, 
			    int sx1, int sy1, int sx2, int sy2, 
			    Color bgcolor, ImageObserver observer)
  {
    if (addObserver(observer))
      return false;

    boolean flipX = (dx1 > dx2)^(sx1 > sx2);
    boolean flipY = (dy1 > dy2)^(sy1 > sy2);
    int dstWidth = Math.abs (dx2 - dx1);
    int dstHeight = Math.abs (dy2 - dy1);
    int srcWidth = Math.abs (sx2 - sx1);
    int srcHeight = Math.abs (sy2 - sy1);
    int srcX = (sx1 < sx2) ? sx1 : sx2;
    int srcY = (sy1 < sy2) ? sy1 : sy2;
    int dstX = (dx1 < dx2) ? dx1 : dx2;
    int dstY = (dy1 < dy2) ? dy1 : dy2;

    // Clipping. This requires the dst to be scaled as well, 
    if (srcWidth > width)
      {
	dstWidth = (int)((double)dstWidth*((double)width/(double)srcWidth));
	srcWidth = width - srcX;
      }

    if (srcHeight > height) 
      {
	dstHeight = (int)((double)dstHeight*((double)height/(double)srcHeight));
	srcHeight = height - srcY;
      }

    if (srcWidth + srcX > width)
      {
	dstWidth = (int)((double)dstWidth * (double)(width - srcX)/(double)srcWidth);
	srcWidth = width - srcX;
      }

    if (srcHeight + srcY > height)
      {
	dstHeight = (int)((double)dstHeight * (double)(width - srcY)/(double)srcHeight);
	srcHeight = height - srcY;
      }

    if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0)
      return true;

    synchronized(GdkPixbufDecoder.pixbufLock)
      {
	if(bgcolor != null)
	  drawPixelsScaledFlipped (g, bgcolor.getRed (), bgcolor.getGreen (), 
				   bgcolor.getBlue (), 
				   flipX, flipY,
				   srcX, srcY,
				   srcWidth, srcHeight,
				   dstX,  dstY,
				   dstWidth, dstHeight,
				   true);
	else
	  drawPixelsScaledFlipped (g, 0, 0, 0, flipX, flipY,
				   srcX, srcY, srcWidth, srcHeight,
				   dstX,  dstY, dstWidth, dstHeight,
				   false);
      }
    return true;
  }

  /**
   * Draws an image to the GdkGraphics context, at (x,y) scaled to 
   * width and height, with optional compositing with a background color.
   */
  public boolean drawImage (GdkGraphics g, int x, int y, int width, int height,
			    Color bgcolor, ImageObserver observer)
  {
    if (addObserver(observer))
      return false;

    synchronized(GdkPixbufDecoder.pixbufLock)
      {
	if(bgcolor != null)
	  drawPixelsScaled(g, bgcolor.getRed (), bgcolor.getGreen (), 
			   bgcolor.getBlue (), x, y, width, height, true);
	else
	  drawPixelsScaled(g, 0, 0, 0, x, y, width, height, false);
      }

    return true;
  }

  // Private methods ////////////////////////////////////////////////

  /**
   * Delivers notifications to all queued observers.
   */
  private void deliver()
  {
    int flags = ImageObserver.HEIGHT | 
      ImageObserver.WIDTH |
      ImageObserver.PROPERTIES |
      ImageObserver.ALLBITS;

    if (observers != null)
      for(int i=0; i < observers.size(); i++)
	((ImageObserver)observers.elementAt(i)).
	  imageUpdate(this, flags, 0, 0, width, height);

    observers = null;
  }
  
  /**
   * Adds an observer, if we need to.
   * @return true if an observer was added.
   */
  private boolean addObserver(ImageObserver observer)
  {
    if (!isLoaded)
      {
	if(observer != null)
	  if (!observers.contains (observer))
	    observers.addElement (observer);
	return true;
      }
    return false;
  }
}