RGBImage.java
上传用户:haobig99
上传日期:2022-06-15
资源大小:369k
文件大小:7k
源码类别:

J2ME

开发平台:

Java

  1. /*
  2.  * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4.  *
  5.  * This code is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License version 2 only, as
  7.  * published by the Free Software Foundation.  Sun designates this
  8.  * particular file as subject to the "Classpath" exception as provided
  9.  * by Sun in the LICENSE file that accompanied this code.
  10.  *
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * version 2 for more details (a copy is included in the LICENSE file that
  15.  * accompanied this code).
  16.  *
  17.  * You should have received a copy of the GNU General Public License version
  18.  * 2 along with this work; if not, write to the Free Software Foundation,
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20.  *
  21.  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22.  * CA 95054 USA or visit www.sun.com if you need additional information or
  23.  * have any questions.
  24.  */
  25. package com.sun.lwuit;
  26. /**
  27.  * An image that stores its data as an integer RGB array internally,
  28.  * this image cannot be manipulated via Graphics primitives however its
  29.  * array is accessible and modifiable programmatically. This is very useful
  30.  * for 2 distinct use cases. 
  31.  * <p>The first use case allows us to manipulate images in 
  32.  * a custom way while still preserving alpha information where applicable.
  33.  * <p>The second use case allows us to store images in the Java heap which is useful
  34.  * for some constrained devices. In small devices images are often stored 
  35.  * in a separate "heap" which runs out eventually, this allows us to place
  36.  * the image in the Java heap which is potentially more wasteful but might
  37.  * sometimes be more abundant. 
  38.  * <p>Note that unless specified otherwise most methods inherited from Image will
  39.  * fail when invoked on this subclass often with a NullPointerException. This
  40.  * image can be drawn on graphics as usual
  41.  * 
  42.  * @author Shai Almog
  43.  */
  44. public class RGBImage extends Image {
  45.     private int width;
  46.     private int height;
  47.     private int[] rgb;
  48.     private boolean opaque;
  49.     
  50.     /**
  51.      * Converts an image to an RGB image after which the original image can be GC'd
  52.      * 
  53.      * @param img the image to convert to an RGB image
  54.      */
  55.     public RGBImage(Image img) {
  56.         super(null);
  57.         width = img.getWidth();
  58.         height = img.getHeight();
  59.         rgb = img.getRGBCached();
  60.     }
  61.     /**
  62.      * Creates an RGB image from scratch the array isn't copied and can be saved
  63.      * and manipulated
  64.      * 
  65.      * @param rgb AARRGGBB array
  66.      * @param width width of image
  67.      * @param height height of image
  68.      */
  69.     public RGBImage(int[] rgb, int width, int height) {
  70.         super(null);
  71.         this.width = width;
  72.         this.height = height;
  73.         this.rgb = rgb;
  74.     }
  75.     /**
  76.      * @inheritDoc
  77.      */
  78.     public Image subImage(int x, int y, int width, int height, boolean processAlpha)  {
  79.         int[] arr = new int[width * height];
  80.         for(int iter = 0 ; iter < arr.length ; iter++) {
  81.             int destY = iter / width;
  82.             int destX = iter % width;
  83.             int offset = x + destX + ((y + destY) * this.width);
  84.             arr[iter] = rgb[offset];
  85.         }
  86.         
  87.         return new RGBImage(arr, width, height);
  88.     }
  89.     /**
  90.      * @inheritDoc
  91.      */
  92.     public Image scaled(int width, int height) {
  93.         int srcWidth = getWidth();
  94.         int srcHeight = getHeight();
  95.         // no need to scale
  96.         if(srcWidth == width && srcHeight == height){
  97.             return this;
  98.         }
  99.         int[] currentArray = new int[srcWidth];
  100.         int[] destinationArray = new int[width * height];
  101.         scaleArray(srcWidth, srcHeight, height, width, currentArray, destinationArray);
  102.         // currently we only support byte data...
  103.         return new RGBImage(destinationArray, width, height);
  104.     }
  105.     /**
  106.      * @inheritDoc
  107.      */
  108.     public void scale(int width, int height) {
  109.         int srcWidth = getWidth();
  110.         int srcHeight = getHeight();
  111.         // no need to scale
  112.         if(srcWidth == width && srcHeight == height){
  113.             return;
  114.         }
  115.         int[] currentArray = new int[srcWidth];
  116.         int[] destinationArray = new int[width * height];
  117.         scaleArray(srcWidth, srcHeight, height, width, currentArray, destinationArray);
  118.         this.width = width;
  119.         this.height = height;
  120.         this.rgb = destinationArray;
  121.     }
  122.     /**
  123.      * Unsupported in the current version, this method will be implemented in a future release
  124.      */
  125.     public Image rotate(int degrees) {
  126.         throw new RuntimeException("The rotate method is not supported by RGB images at the moment");
  127.     }
  128.     
  129.     /**
  130.      * @inheritDoc
  131.      */
  132.     public Image modifyAlpha(byte alpha) {
  133.         int[] arr = new int[rgb.length];
  134.         System.arraycopy(rgb, 0, arr, 0, rgb.length);
  135.         int alphaInt = (((int)alpha) << 24) & 0xff000000;
  136.         for(int iter = 0 ; iter < rgb.length ; iter++) {
  137.             if((arr[iter] & 0xff000000) != 0) {
  138.                 arr[iter] = (arr[iter] & 0xffffff) | alphaInt;
  139.             }
  140.         }
  141.         return new RGBImage(arr, width, height);
  142.     }
  143.     
  144.     /**
  145.      * This method is unsupported in this image type
  146.      */
  147.     public Graphics getGraphics() {
  148.         throw new RuntimeException("RGBImage objects can't be modified via graphics");
  149.     }
  150.     
  151.     
  152.     /**
  153.      * Returns a mutable array that can be used to change the appearance of the image
  154.      * arranged as AARRGGBB.
  155.      * 
  156.      * @return ARGB int array
  157.      */
  158.     public int[] getRGB() {
  159.         return rgb;
  160.     }
  161.     /**
  162.      * @inheritDoc
  163.      */
  164.     void getRGB(int[] rgbData,
  165.             int offset,
  166.             int x,
  167.             int y,
  168.             int width,
  169.             int height){
  170.         int startPoint = y * this.width + x;
  171.         for(int rows = 0 ; rows < height ; rows++) {
  172.             int currentRow = rows * width;
  173.             for(int columns = 0 ; columns < width ; columns++) {
  174.                 rgbData[offset + currentRow + columns] = rgb[startPoint + columns];
  175.             }
  176.             startPoint += this.width;
  177.         }
  178.     }
  179.     /**
  180.      * @inheritDoc
  181.      */
  182.     protected void drawImage(Graphics g, Object nativeGraphics, int x, int y) {
  183.        g.drawRGB(rgb, 0, x, y, width, height, !opaque);
  184.     }    
  185.     /**
  186.      * @inheritDoc
  187.      */
  188.     public void setOpaque(boolean opaque) {
  189.         this.opaque = opaque;
  190.     }
  191.     /**
  192.      * Indicates if an image should be treated as opaque, this can improve support
  193.      * for fast drawing of RGB images without alpha support.
  194.      */
  195.     public boolean isOpaque() {
  196.         return opaque;
  197.     }
  198.     
  199.     /**
  200.      * @inheritDoc
  201.      */
  202.     public int getWidth() {
  203.         return width;
  204.     }
  205.     
  206.     /**
  207.      * @inheritDoc
  208.      */
  209.     public int getHeight() {
  210.         return height;
  211.     }
  212. }