2003-12-26 Guilhem Lavaux <guilhem@kaffe.org>

[official-gcc.git] / libjava / gnu / awt / xlib / XGraphicsConfiguration.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");
    }
  }

  void calcZPixmapModels(int bitsPerPixel)
  {
    switch (visual.getVisualClass())
      {
      case Visual.VC_TRUE_COLOR:
        calcDecomposedRGBModels(bitsPerPixel);
        break;
      case Visual.VC_PSEUDO_COLOR:
        calcPseudoColorModels(bitsPerPixel);
        break;
      default:
        String msg = "unimplemented visual class";
        throw new UnsupportedOperationException(msg);
      }
  }
    
  void calcDecomposedRGBModels(int bitsPerPixel)
  {
    int dataType = Buffers.smallestAppropriateTransferType(bitsPerPixel);
    
    
    if (DataBuffer.getDataTypeSize(dataType) == bitsPerPixel)
      { 
        ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
        
        imageCM = new DirectColorModel(cs,
                                       visual.getDepth(),
                                       visual.getRedMask(),
                                       visual.getGreenMask(),
                                       visual.getBlueMask(),
                                       0, // no alpha
                                       false,
                                       dataType);
      }
    else
      {
        throw new
          UnsupportedOperationException("unimplemented bits per pixel");
      }
    }
    
  void calcPseudoColorModels(int bitsPerPixel)
  {
    if (colormap == null)
      colormap = visual.getScreen().getDefaultColormap();
    
    XColor[] colArray = colormap.getXColors();
        
    int numCol = colArray.length;
    byte[] rmap = new byte[numCol];
    byte[] gmap = new byte[numCol];
    byte[] bmap = new byte[numCol];
    byte[] amap = new byte[numCol];
    
    for (int i=0; i < numCol; i++)
      {
        XColor color = colArray[i];
        if (color.getFlags() == Colormap.FLAG_SHARED)
          {
            rmap[i] = (byte) (color.getRed()   >> 8);
            gmap[i] = (byte) (color.getGreen() >> 8);
            bmap[i] = (byte) (color.getBlue()  >> 8);
            amap[i] = (byte) 0xff;
          } // else, leave default zero values...
      }

    imageCM = new IndexColorModel(visual.getDepth(), numCol,
                                  rmap, gmap, bmap, amap);
  }

  /**
   * Gets the associated device that this configuration describes.
   *
   * @return the device
   */
  public GraphicsDevice getDevice()
  {
    throw new UnsupportedOperationException("not implemented");  
  }

  /**
   * Returns a buffered image optimized to this device, so that blitting can
   * be supported in the buffered image.
   *
   * @param w the width of the buffer
   * @param h the height of the buffer
   * @return the buffered image, or null if none is supported
   */
  public BufferedImage createCompatibleImage(int width,
                                             int height,
                                             int transparency)
  {
    throw new UnsupportedOperationException("not implemented");
  }

  /**
   * Returns a buffered volatile image optimized to this device, so that
   * blitting can be supported in the buffered image. Because the buffer is
   * volatile, it can be optimized by native graphics accelerators.
   *
   * @param w the width of the buffer
   * @param h the height of the buffer
   * @return the buffered image, or null if none is supported
   * @see Component#createVolatileImage(int, int)
   * @since 1.4
   */
  public VolatileImage createCompatibleVolatileImage(int w, int h)
  {
    throw new UnsupportedOperationException("not implemented");
  }

  /**
   * FIXME: I'm not sure which color model that should be returned here.
   */
  public ColorModel getColorModel()
  {
    if (pixelCM == null)
      preparePixelCM();
    return pixelCM;
  }

  void preparePixelCM()
  {
    switch (visual.getVisualClass())
      {
      case Visual.VC_TRUE_COLOR:
        pixelCM = new DirectColorModel(visual.getDepth(),
                                       visual.getRedMask(),
                                       visual.getGreenMask(),
                                       visual.getBlueMask());
        break;
      case Visual.VC_PSEUDO_COLOR:

        if (colormap == null)
          colormap = visual.getScreen().getDefaultColormap();
        
        XColor[] colArray = colormap.getXColors();
        
        int numCol = colArray.length;
        byte[] rmap = new byte[numCol];
        byte[] gmap = new byte[numCol];
        byte[] bmap = new byte[numCol];
        byte[] amap = new byte[numCol];
        
        for (int i=0; i < numCol; i++)
          {
            XColor color = colArray[i];
            if (color.getFlags() == Colormap.FLAG_SHARED) {
              rmap[i] = (byte) (color.getRed()   >> 8);
              gmap[i] = (byte) (color.getGreen() >> 8);
              bmap[i] = (byte) (color.getBlue()  >> 8);
              amap[i] = (byte) 0xff;
            } // else, leave default zero values...

          }

        pixelCM = new IndexColorModel(visual.getDepth(), numCol,
                                      rmap, gmap, bmap, amap);
        break;
      default:
        throw new UnsupportedOperationException("not implemented");
      }
  }
  
  public ColorModel getColorModel(int transparency)
  {
    throw new UnsupportedOperationException("not implemented");
  }
    
  public AffineTransform getDefaultTransform()
  {
    throw new UnsupportedOperationException("not implemented");
  }

  public AffineTransform getNormalizingTransform()
  {
    throw new UnsupportedOperationException("not implemented");
  }
 
  public Rectangle getBounds()
  {
    throw new UnsupportedOperationException("not implemented");
  }

  Visual getVisual()
  {
    return visual;
  }
    
  /* FIXME: This should be moved to XGraphicsDevice... */
  XFontMetrics getXFontMetrics (java.awt.Font awtFont)
  {
    // If the metrics object for this font is already cached, use it.
    // Otherwise create and cache it.
    Display display = visual.getScreen ().getDisplay ();
    XFontMetrics fm = fontMetricsCache.get (awtFont,display);
    if (fm == null)
    {
      String foundry      = "*";
      String family       = awtFont.getName ();
      String weight       = awtFont.isBold () ? "bold" : "medium";
      String slant        = awtFont.isItalic () ? "i" : "r";
      String sWidth       = "*";
      String addStyle     = "";
      String pixelSize    = "*";
      String pointSize    = awtFont.getSize () + "0";
      String xres         = "*";
      String yres         = "*";
      String spacing      = "*";
      String averageWidth = "*";
      String charset      = "iso10646-1"; // because we use functions like XDrawString16
      
      String logicalFontDescription =
        "-" + // FontNameRegistry prefix
        foundry   + "-" + family    + "-" + weight       + "-" +
        slant     + "-" + sWidth    + "-" + addStyle     + "-" +
        pixelSize + "-" + pointSize + "-" + xres         + "-" +
        yres      + "-" + spacing   + "-" + averageWidth + "-";
      
      // Try to load a Unicode font.  If that doesn't work, try again, without
      // specifying the character set.
      try
      {
        gnu.gcj.xlib.Font xfont = new gnu.gcj.xlib.Font (display, logicalFontDescription + charset);
        fm = new XFontMetrics (xfont, awtFont);
      }
      catch (XException e)
      {
        gnu.gcj.xlib.Font xfont = new gnu.gcj.xlib.Font (display, logicalFontDescription + "*-*");
        fm = new XFontMetrics (xfont, awtFont);
      }
      fontMetricsCache.put (awtFont,display,fm);
    }
    return fm;
  }

  int getPixel(Color color)
  {
    /* FIXME: consider an integer technique whenever
     * the ColorModel is 8 bits per color.
     * The problem with using integers is that it doesn't work unless
     * the colors are 8 bits each (as in the array), since ColorModel.getDataElement(int[],int)
     * expects non-normalized values.  For example, in a 16-bit display mode, you
     * would typically have 5 bits each for red and blue, and 6 bits for green.
    int[] components =
    {
      color.getRed (),
      color.getGreen (),
      color.getBlue (),
      0xff
    };
     */
    
    float[] normalizedComponents =
    {
      ((float)color.getRed ()) / 255F,
      ((float)color.getGreen ()) / 255F,
      ((float)color.getBlue ()) / 255F,
      1
    };
    int[] unnormalizedComponents = { 0, 0, 0, 0xff };
    ColorModel cm = getColorModel ();
    cm.getUnnormalizedComponents(normalizedComponents, 0,
                                 unnormalizedComponents, 0);
    return cm.getDataElement (unnormalizedComponents, 0);
  }
}