home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Main.bin / DirectColorModel.java < prev    next >
Text File  |  1998-09-22  |  7KB  |  237 lines
  1. /*
  2.  * @(#)DirectColorModel.java    1.15 98/07/01
  3.  *
  4.  * Copyright 1995-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  * 
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.awt.image;
  16.  
  17. import java.awt.AWTException;
  18.  
  19. /**
  20.  * A ColorModel class that specifies a translation from pixel values
  21.  * to alpha, red, green, and blue color components for pixels which
  22.  * have the color components embedded directly in the bits of the
  23.  * pixel itself.  This color model is similar to an X11 TrueColor
  24.  * visual.
  25.  
  26.  * <p>Many of the methods in this class are final. This is because the
  27.  * underlying native graphics code makes  assumptions about the layout
  28.  * and operation of this class  and those assumptions are reflected in
  29.  * the implementations of the methods here that are marked final.  You
  30.  * can subclass this class  for other reaons,  but you cannot override
  31.  * or modify the behaviour of those methods.
  32.  *
  33.  * @see ColorModel
  34.  *
  35.  * @version    1.15 07/01/98
  36.  * @author     Jim Graham
  37.  */
  38. public class DirectColorModel extends ColorModel {
  39.     private int red_mask;
  40.     private int green_mask;
  41.     private int blue_mask;
  42.     private int alpha_mask;
  43.     private int red_offset;
  44.     private int green_offset;
  45.     private int blue_offset;
  46.     private int alpha_offset;
  47.     private int red_scale;
  48.     private int green_scale;
  49.     private int blue_scale;
  50.     private int alpha_scale;
  51.  
  52.     /**
  53.      * Constructs a DirectColorModel from the given masks specifying
  54.      * which bits in the pixel contain the red, green and blue color
  55.      * components.  Pixels described by this color model will all
  56.      * have alpha components of 255 (fully opaque).  All of the bits
  57.      * in each mask must be contiguous and fit in the specified number
  58.      * of least significant bits of the integer.
  59.      */
  60.     public DirectColorModel(int bits,
  61.                 int rmask, int gmask, int bmask) {
  62.     this(bits, rmask, gmask, bmask, 0);
  63.     }
  64.  
  65.     /**
  66.      * Constructs a DirectColorModel from the given masks specifying
  67.      * which bits in the pixel contain the alhpa, red, green and blue
  68.      * color components.  All of the bits in each mask must be contiguous
  69.      * and fit in the specified number of least significant bits of the
  70.      * integer.
  71.      */
  72.     public DirectColorModel(int bits,
  73.                 int rmask, int gmask, int bmask, int amask) {
  74.     super(bits);
  75.     red_mask = rmask;
  76.     green_mask = gmask;
  77.     blue_mask = bmask;
  78.     alpha_mask = amask;
  79.     CalculateOffsets();
  80.     }
  81.  
  82.     /**
  83.      * Returns the mask indicating which bits in a pixel contain the red
  84.      * color component.
  85.      */
  86.     final public int getRedMask() {
  87.     return red_mask;
  88.     }
  89.  
  90.     /**
  91.      * Returns the mask indicating which bits in a pixel contain the green
  92.      * color component.
  93.      */
  94.     final public int getGreenMask() {
  95.     return green_mask;
  96.     }
  97.  
  98.     /**
  99.      * Returns the mask indicating which bits in a pixel contain the blue
  100.      * color component.
  101.      */
  102.     final public int getBlueMask() {
  103.     return blue_mask;
  104.     }
  105.  
  106.     /**
  107.      * Returns the mask indicating which bits in a pixel contain the alpha
  108.      * transparency component.
  109.      */
  110.     final public int getAlphaMask() {
  111.     return alpha_mask;
  112.     }
  113.  
  114.     private int accum_mask = 0;
  115.  
  116.     /*
  117.      * A utility function to decompose a single mask and verify that it
  118.      * fits in the specified pixel size, and that it does not overlap any
  119.      * other color component.  The values necessary to decompose and
  120.      * manipulate pixels are calculated as a side effect.
  121.      */
  122.     private void DecomposeMask(int mask, String componentName, int values[]) {
  123.     if ((mask & accum_mask) != 0) {
  124.         throw new IllegalArgumentException(componentName + " mask bits not unique");
  125.     }
  126.     int off = 0;
  127.     int count = 0;
  128.     if (mask != 0) {
  129.         while ((mask & 1) == 0) {
  130.         mask >>>= 1;
  131.         off++;
  132.         }
  133.         while ((mask & 1) == 1) {
  134.         mask >>>= 1;
  135.         count++;
  136.         }
  137.     }
  138.     if (mask != 0) {
  139.         throw new IllegalArgumentException(componentName + " mask bits not contiguous");
  140.     }
  141.     if (off + count > pixel_bits) {
  142.         throw new IllegalArgumentException(componentName + " mask overflows pixel");
  143.     }
  144.     int scale;
  145.     if (count < 8) {
  146.         scale = (1 << count) - 1;
  147.     } else {
  148.         scale = 0;
  149.         if (count > 8) {
  150.         off += (count - 8);
  151.         }
  152.     }
  153.     values[0] = off;
  154.     values[1] = scale;
  155.     }
  156.  
  157.     /*
  158.      * A utility function to verify all of the masks and to store
  159.      * the auxilliary values needed to manipulate the pixels.
  160.      */
  161.     private void CalculateOffsets() {
  162.     int values[] = new int[2];
  163.     DecomposeMask(red_mask, "red", values);
  164.     red_offset = values[0];
  165.     red_scale = values[1];
  166.     DecomposeMask(green_mask, "green", values);
  167.     green_offset = values[0];
  168.     green_scale = values[1];
  169.     DecomposeMask(blue_mask, "blue", values);
  170.     blue_offset = values[0];
  171.     blue_scale = values[1];
  172.     DecomposeMask(alpha_mask, "alpha", values);
  173.     alpha_offset = values[0];
  174.     alpha_scale = values[1];
  175.     }
  176.  
  177.     /**
  178.      * Returns the red color compoment for the specified pixel in the
  179.      * range 0-255.
  180.      */
  181.     final public int getRed(int pixel) {
  182.     int r = ((pixel & red_mask) >>> red_offset);
  183.     if (red_scale != 0) {
  184.         r = r * 255 / red_scale;
  185.     }
  186.     return r;
  187.     }
  188.  
  189.     /**
  190.      * Returns the green color compoment for the specified pixel in the
  191.      * range 0-255.
  192.      */
  193.     final public int getGreen(int pixel) {
  194.     int g = ((pixel & green_mask) >>> green_offset);
  195.     if (green_scale != 0) {
  196.         g = g * 255 / green_scale;
  197.     }
  198.     return g;
  199.     }
  200.  
  201.     /**
  202.      * Returns the blue color compoment for the specified pixel in the
  203.      * range 0-255.
  204.      */
  205.     final public int getBlue(int pixel) {
  206.     int b = ((pixel & blue_mask) >>> blue_offset);
  207.     if (blue_scale != 0) {
  208.         b = b * 255 / blue_scale;
  209.     }
  210.     return b;
  211.     }
  212.  
  213.     /**
  214.      * Return the alpha transparency value for the specified pixel in the
  215.      * range 0-255.
  216.      */
  217.     final public int getAlpha(int pixel) {
  218.     if (alpha_mask == 0) return 255;
  219.     int a = ((pixel & alpha_mask) >>> alpha_offset);
  220.     if (alpha_scale != 0) {
  221.         a = a * 255 / alpha_scale;
  222.     }
  223.     return a;
  224.     }
  225.  
  226.     /**
  227.      * Returns the color of the pixel in the default RGB color model.
  228.      * @see ColorModel#getRGBdefault
  229.      */
  230.     final public int getRGB(int pixel) {
  231.     return (getAlpha(pixel) << 24)
  232.         | (getRed(pixel) << 16)
  233.         | (getGreen(pixel) << 8)
  234.         | (getBlue(pixel) << 0);
  235.     }
  236. }
  237.