xgraphicsconfiguration.java

gcc的JAVA模块的源代码

/* Copyright (C) 2000, 2003  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

package gnu.awt.xlib;

import java.awt.GraphicsConfiguration;
import java.awt.Rectangle;
import java.awt.Graphics2D;
import java.awt.Graphics;
import java.awt.GraphicsDevice;
import java.awt.Point;
import java.awt.Color;
import java.awt.color.ColorSpace;
import java.awt.Font;
import java.awt.image.*;
import java.awt.geom.AffineTransform;
import gnu.gcj.xlib.GC;
import gnu.gcj.xlib.Drawable;
import gnu.gcj.xlib.Window;
import gnu.gcj.xlib.XImage;
import gnu.gcj.xlib.Visual;
import gnu.gcj.xlib.Colormap;
import gnu.gcj.xlib.XColor;
import gnu.gcj.xlib.Screen;
import gnu.gcj.xlib.Display;
import gnu.gcj.xlib.XException;
import gnu.java.awt.Buffers;
import java.util.Enumeration;
import java.util.Hashtable;

public class XGraphicsConfiguration extends GraphicsConfiguration
{
  //public abstract GraphicsDevice getDevice();
  
  Visual visual;
  int format;
  Colormap colormap;
  ColorModel imageCM;
  ColorModel pixelCM;
  private static final int CACHE_SIZE_PER_DISPLAY = 10;
  static FontMetricsCache fontMetricsCache = new FontMetricsCache ();
  
  /** Font metrics cache class.  Caches at most CACHE_SIZE_PER_DISPLAY
   * XFontMetrics objects for each display device.  When a display's cache
   * gets full, the least-recently used entry is overwritten.
   * XXX: lruOrder rolls over after a few billion operations, so it might
   * on very rare occasions misinterpret which is the oldest entry
   */
  static class FontMetricsCache
  {
    private java.util.Hashtable displays = new java.util.Hashtable ();
    
    /** Font metrics cache for a display device
     */
    class PerDisplayCache
    {
      private int lruCount = 0;
      private java.util.Hashtable entries = new java.util.Hashtable ();
      
      class CacheEntry
      {
        int lruOrder;
        XFontMetrics fm;
        Font font;
      }
      
      /** Get an entry (null if not there) and update LRU ordering
       */
      XFontMetrics get (Font font)
      {
        CacheEntry entry = (CacheEntry)entries.get (font);
        if (entry != null)
        {
          entry.lruOrder = lruCount++;
        }
        return (entry==null) ? null : entry.fm;
      }
      
      /** Put an entry in the cache, eliminating the oldest entry if
       * the cache is at capacity.
       */
      void put (Font font, XFontMetrics fontMetrics)
      {
        if (entries.size () >= CACHE_SIZE_PER_DISPLAY)
        {
          // cache is full -- eliminate the oldest entry
          // slow operation, but shouldn't happen very often
          int maxAge = 0;
          CacheEntry oldestEntry = null;
          int referenceCount = lruCount;
          for (Enumeration e = entries.elements (); e.hasMoreElements ();)
          {
            CacheEntry entry = (CacheEntry)e.nextElement ();
            if ((referenceCount-entry.lruOrder) > maxAge)
            {
              maxAge = referenceCount-entry.lruOrder;
              oldestEntry = entry;
            }
          }
          if (oldestEntry != null)
            entries.remove (oldestEntry.font);
        }
        CacheEntry newEntry = new CacheEntry ();
        newEntry.lruOrder = lruCount++;
        newEntry.fm = fontMetrics;
        newEntry.font = font;
        entries.put (font,newEntry);
      }
    }
    
    /** Get the font metrics for a font, if it is present in the cache.
     * @param font The AWT font for which to find the font metrics
     * @param display The display, to select the cached entries for that display
     * @return The font metrics, or null if not cached
     */
    XFontMetrics get (Font font, Display display)
    {
      PerDisplayCache cache = (PerDisplayCache)displays.get (display);
      return (cache==null) ? null : cache.get (font);
    }
    
    /** Put a font in the cache
     * @param font The font
     * @param display The display
     * @param fontMetrics The font metrics
     */
    void put (Font font, Display display, XFontMetrics fontMetrics)
    {
      PerDisplayCache cache = (PerDisplayCache)displays.get (display);
      if (cache == null)
      {
        cache = new PerDisplayCache ();
        displays.put (display,cache);
      }
      cache.put (font,fontMetrics);
    }
  }
  
  public XGraphicsConfiguration(Visual visual)
  {
    this.visual = visual;
  }

  public BufferedImage createCompatibleImage(int width, int height)
  {
    XImage ximg = new XImage(visual, width, height,
			     false // do not auto allocate memory
			     );

    Point origin = new Point(0, 0);
    WritableRaster raster = createRasterForXImage(ximg, origin);

    /* This is not a good way of doing this. Multiple toolkits may
       want to share the BufferedImage. */
    Hashtable props = new Hashtable();
    props.put("gnu.gcj.xlib.XImage", ximg);
    props.put("java.awt.GraphicsConfiguration", this);
    
    BufferedImage bimg = new BufferedImage(imageCM,raster, false, props);

    DataBuffer dataB = raster.getDataBuffer();
    attachData(ximg, dataB, 0);
    return bimg;
  }

  WritableRaster createRasterForXImage(XImage ximage, Point origin)
  {
    if (imageCM == null) prepareColorModel(ximage);
    
    /*
      This will not work, since it creates a sample model that
      does not necessarily match the format of the XImage.
      
      WritableRaster raster =
      imageCM.createCompatibleWritableRaster(width, height); */
    
    // Create a sample model matching the XImage:

    SampleModel imageSM = null;

    int width = ximage.getWidth();
    int height = ximage.getHeight();
    int bitsPerPixel = ximage.getBitsPerPixel();
    int dataType =
      Buffers.smallestAppropriateTransferType(bitsPerPixel);
    int bitsPerDataElement = DataBuffer.getDataTypeSize(dataType);
    int scanlineStride = ximage.getBytesPerLine()*8/bitsPerDataElement;
    
    if (imageCM instanceof IndexColorModel)
      {
	int[] bandOffsets = {0};
	imageSM = new ComponentSampleModel(dataType,
					   width, height,
					   1, // pixel stride
					   scanlineStride,
					   bandOffsets);
      }
    else if (imageCM instanceof PackedColorModel)
      {
	PackedColorModel pcm = (PackedColorModel) imageCM;
	int[] masks = pcm.getMasks();
	
	imageSM = new SinglePixelPackedSampleModel(dataType,
						   width, height,
						   scanlineStride,
						   masks);
      }

    if (imageSM == null)
      {
	throw new UnsupportedOperationException("creating sample model " +
						"for " + imageCM +
						" not implemented");
      }

    WritableRaster raster = Raster.createWritableRaster(imageSM, origin);
    return raster;
  }



  /**
   * Attach a the memory of a data buffer to an XImage
   * structure. [This method is not gnu.awt.xlib specific, and should
   * maybe be moved to a different location.]
   *
   * @param offset Offset to data. The given offset does not include
   * data buffer offset, which will also be added.  
   */
  static void attachData(XImage ximage, DataBuffer dataB, int offset)
  {
    offset += dataB.getOffset();
    switch (dataB.getDataType())
      {
      case DataBuffer.TYPE_BYTE:
	ximage.setData(((DataBufferByte) dataB).getData(), offset);
	break;
      case DataBuffer.TYPE_USHORT:
	ximage.setData(((DataBufferUShort) dataB).getData(), offset);
	break;
      case DataBuffer.TYPE_INT:
	ximage.setData(((DataBufferInt) dataB).getData(), offset);
	break;
      default:
	throw
	  new UnsupportedOperationException("Do not know how to " +
					    "set data for data " +
					    "type " +
					    dataB.getDataType());
      }
  }
    
  void prepareColorModel(XImage ximage)
  {
    format = ximage.getFormat();
    int bitsPerPixel = ximage.getBitsPerPixel();
    switch (format) {
    case XImage.ZPIXMAP_FORMAT:
      calcZPixmapModels(bitsPerPixel);
      break;
      
    default:
      throw new UnsupportedOperationException("unimplemented format");
    }
  }