Java Doc for Image.java in  » 6.0-JDK-Modules » j2me » javax » microedition » lcdui » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » 6.0 JDK Modules » j2me » javax.microedition.lcdui 
Source Cross Reference  Class Diagram Java Document (Java Doc) 


java.lang.Object
   javax.microedition.lcdui.Image

Image
public class Image (Code)
The Image class is used to hold graphical image data. Image objects exist independently of the display device. They exist only in off-screen memory and will not be painted on the display unless an explicit command is issued by the application (such as within the paint() method of a Canvas) or when an Image object is placed within a Form screen or an Alert screen and that screen is made current.

Images are either mutable or immutable depending upon how they are created. Immutable images are generally created by loading image data from resource bundles, from files, or from the network. They may not be modified once created. Mutable images are created as blank images containing only white pixels. The application may render on a mutable image by calling Image.getGraphics on the Image to obtain a Graphics object expressly for this purpose.

Images may be placed within Alert, Choice, Form, or ImageItem objects. The high-level user interface implementation may need to update the display at any time, without notifying the application. In order to provide predictable behavior, the high-level user interface objects provide snapshot semantics for the image. That is, when a mutable image is placed within an Alert, Choice, Form, or ImageItem object, the effect is as if a snapshot is taken of its current contents. This snapshot is then used for all subsequent painting of the high-level user interface component. If the application modifies the contents of the image, the application must update the component containing the image (for example, by calling ImageItem.setImage) in order to make the modified contents visible.

An immutable image may be created from a mutable image through the use of the Image.createImage(Image) createImage method. It is possible to create a mutable copy of an immutable image using a technique similar to the following:


 Image source; // the image to be copied    
 source = Image.createImage(...);    
 Image copy = Image
 .createImage(source.getWidth(), source.getHeight());        
 Graphics g = copy.getGraphics();    
 g.drawImage(source, 0, 0, TOP|LEFT);       

Alpha Processing

Every pixel within a mutable image is always fully opaque. Immutable images may contain a combination of fully opaque pixels (alpha = 2bitdepth - 1), fully transparent pixels (alpha = 0), and semitransparent pixels (0 < alpha <  2bitdepth - 1), where bitdepth is the number of bits per sample in the source data.

Implementations must support storage, processing, and rendering of fully opaque pixels and fully transparent pixels in immutable images. When creating an image from source data (whether from a PNG file or from an array of ARGB data), a fully opaque pixel in the source data must always result in a fully opaque pixel in the new image, and a fully transparent pixel in the source data must always result in a fully transparent pixel in the new image.

The required treatment of semitransparent pixel data depends upon whether the implementation supports alpha blending at rendering time. If the implementation supports alpha blending, a semitransparent pixel in the source data must result in a semitransparent pixel in the new image. The resulting alpha value may be modified to accommodate the number of levels of semitransparency supported by the platform. (See the Display.numAlphaLevels Display.numAlphaLevels() method.) If an implementation does not support alpha blending, any semitransparent pixels in the source data must be replaced with fully transparent pixels in the new image.

PNG Image Format

Implementations are required to support images stored in the PNG format, as specified by the PNG (Portable Network Graphics) Specification, Version 1.0. All conforming MIDP implementations are also conformant to the minimum set of requirements given by the PNG Specification. MIDP implementations also must conform to additional requirements given here with respect to handling of PNG images. Note that the requirements listed here take precedence over any conflicting recommendations given in the PNG Specification.

Critical Chunks

All of the 'critical' chunks specified by PNG must be supported. The paragraphs below describe these critical chunks.

The IHDR chunk. MIDP devices must handle the following values in the IHDR chunk:

  • All positive values of width and height are supported; however, a very large image may not be readable because of memory constraints. The dimensions of the resulting Image object must match the dimensions of the PNG image. That is, the values returned by Image.getWidth() getWidth() and Image.getHeight() getHeight() and the rendered width and height must equal the width and height specified in the IHDR chunk.
  • All color types are supported, although the appearance of the image will be dependent on the capabilities of the device's screen. Color types that include alpha channel data are supported.
  • For color types 4 & 6 (grayscale with alpha and RGB with alpha, respectively) the alpha channel must be decoded. Any pixels with an alpha value of zero must be treated as transparent. Any pixels with an alpha value of 255 (for images with 8 bits per sample) or 65535 (for images with 16 bits per sample) must be treated as opaque. If rendering with alpha blending is supported, any pixels with intermediate alpha values must be carried through to the resulting image. If alpha blending is not supported, any pixels with intermediate alpha values must be replaced with fully transparent pixels.
  • All bit depth values for the given color type are supported.
  • Compression method 0 (deflate) is the only supported compression method. This method utilizes the "zlib" compression scheme, which is also used for jar files; thus, the decompression (inflate) code may be shared between the jar decoding and PNG decoding implementations. As noted in the PNG specification, the compressed data stream may comprised internally of both compressed and uncompressed (raw) data.
  • The filter method represents a series of encoding schemes that may be used to optimize compression. The PNG spec currently defines a single filter method (method 0) that is an adaptive filtering scheme with five basic filter types. Filtering is essential for optimal compression since it allows the deflate algorithm to exploit spatial similarities within the image. Therefore, MIDP devices must support all five filter types defined by filter method 0.
  • MIDP devices are required to read PNG images that are encoded with either interlace method 0 (None) or interlace method 1 (Adam7). Image loading in MIDP is synchronous and cannot be overlapped with image rendering, and so there is no advantage for an application to use interlace method 1. Support for decoding interlaced images is required for compatibility with PNG and for the convenience of developers who may already have interlaced images available.

The PLTE chunk. Palette-based images must be supported.

The IDAT chunk. Image data may be encoded using any of the 5 filter types defined by filter method 0 (None, Sub, Up, Average, Paeth).

The IEND chunk. This chunk must be found in order for the image to be considered valid.

Ancillary Chunks

PNG defines several 'ancillary' chunks that may be present in a PNG image but are not critical for image decoding.

The tRNS chunk. All implementations must support the tRNS chunk. This chunk is used to implement transparency without providing alpha channel data for each pixel. For color types 0 and 2, a particular gray or RGB value is defined to be a transparent pixel. In this case, the implementation must treat pixels with this value as fully transparent. Pixel value comparison must be based on the actual pixel values using the original sample depth; that is, this comparison must be performed before the pixel values are resampled to reflect the display capabilities of the device. For color type 3 (indexed color), 8-bit alpha values are potentially provided for each entry in the color palette. In this case, the implementation must treat pixels with an alpha value of 0 as fully transparent, and it must treat pixels with an alpha value of 255 as fully opaque. If rendering with alpha blending is supported, any pixels with intermediate alpha values must be carried through to the resulting image. If alpha blending is not supported, any pixels with intermediate alpha values must be replaced with fully transparent pixels.

The implementation may (but is not required to) support any of the other ancillary chunks. The implementation must silently ignore any unsupported ancillary chunks that it encounters. The currently defined optional ancillary chunks are:

 cHRM gAMA hIST iCCP iTXt pHYs
 sBIT sPLT sRGB tEXt tIME zTXt 

Reference

PNG (Portable Network Graphics) Specification, Version 1.0. W3C Recommendation, October 1, 1996. http://www.w3.org/TR/REC-png.html. Also available as RFC 2083, http://www.ietf.org/rfc/rfc2083.txt.


since:
   MIDP 1.0


Field Summary
final static  intINVALID_TRANSFORM_BITS
    
final static  intTRANSFORM_SWAP_AXIS
    


Method Summary
public static  ImagecreateImage(int width, int height)
     Creates a new, mutable image for off-screen drawing.
public static  ImagecreateImage(Image source)
     Creates an immutable image from a source image. If the source image is mutable, an immutable copy is created and returned.
public static  ImagecreateImage(java.lang.String name)
     Creates an immutable image from decoded image data obtained from the named resource.
public static  ImagecreateImage(byte[] imageData, int imageOffset, int imageLength)
     Creates an immutable image which is decoded from the data stored in the specified byte array at the specified offset and length.
public static  ImagecreateImage(Image image, int x, int y, int width, int height, int transform)
     Creates an immutable image using pixel data from the specified region of a source image, transformed as specified.

The source image may be mutable or immutable.

public static  ImagecreateImage(InputStream stream)
     Creates an immutable image from decoded image data obtained froH an InputStream.
public static  ImagecreateRGBImage(int rgb, int width, int height, boolean processAlpha)
     Creates an immutable image from a sequence of ARGB values, specified as 0xAARRGGBB. The ARGB data within the rgb array is arranged horizontally from left to right within each row, row by row from top to bottom. If processAlpha is true, the high-order byte specifies opacity; that is, 0x00RRGGBB specifies a fully transparent pixel and 0xFFRRGGBB specifies a fully opaque pixel.
public  GraphicsgetGraphics()
     Creates a new Graphics object that renders to this image.
public  intgetHeight()
     Gets the height of the image in pixels.
 ImageDatagetImageData()
     Returns ImageData associated with this Image.
native public  voidgetRGB(int[] rgbData, int offset, int scanlength, int x, int y, int width, int height)
    
static  ImagegetRomizedImage(int imageDataArrayPtr, int imageDataArrayLength)
     Function to load an romized Image.
Parameters:
  imageDataArrayPtr - native pointer to image data as Java int
Parameters:
  imageDataArrayLength - length of image data array image created.
public  intgetWidth()
     Gets the width of the image in pixels.
public  booleanisMutable()
     Check if this image is mutable.
native  booleanrender(Graphics g, int x, int y, int anchor)
     Renders this Image onto the provided Graphics object.
native  booleanrenderRegion(Graphics g, int x_src, int y_src, int width, int height, int transform, int x_dest, int y_dest, int anchor)
     Renders the specified region onto the provided Graphics object.
 voidresize(int width, int height, boolean keepContent)
    

Field Detail
INVALID_TRANSFORM_BITS
final static int INVALID_TRANSFORM_BITS(Code)
Valid transforms possible are 0 - 7



TRANSFORM_SWAP_AXIS
final static int TRANSFORM_SWAP_AXIS(Code)
Transform swap axis bit is the 3 bit





Method Detail
createImage
public static Image createImage(int width, int height)(Code)
Creates a new, mutable image for off-screen drawing. Every pixel within the newly created image is white. The width and height of the image must both be greater than zero.
Parameters:
  width - the width of the new image, in pixels
Parameters:
  height - the height of the new image, in pixels the created image
throws:
  IllegalArgumentException - if either width orheight is zero or less



createImage
public static Image createImage(Image source)(Code)
Creates an immutable image from a source image. If the source image is mutable, an immutable copy is created and returned. If the source image is immutable, the implementation may simply return it without creating a new image. If an immutable source image contains transparency information, this information is copied to the new image unchanged.

This method is useful for placing the contents of mutable images into Choice objects. The application can create an off-screen image using the Image.createImage(int,int) createImage(w, h) method, draw into it using a Graphics object obtained with the Image.getGraphics() getGraphics() method, and then create an immutable copy of it with this method. The immutable copy may then be placed into Choice objects.


Parameters:
  source - the source image to be copied the new, immutable image
throws:
  NullPointerException - if source is null



createImage
public static Image createImage(java.lang.String name) throws java.io.IOException(Code)
Creates an immutable image from decoded image data obtained from the named resource. The name parameter is a resource name as defined by Class.getResourceAsStream(String)Class.getResourceAsStream(name) . The rules for resolving resource names are defined in the Application Resource Files section of the java.lang package documentation.
Parameters:
  name - the name of the resource containing the image data in one ofthe supported image formats the created image
throws:
  NullPointerException - if name is null
throws:
  java.io.IOException - if the resource does not exist,the data cannotbe loaded, or the image data cannot be decoded



createImage
public static Image createImage(byte[] imageData, int imageOffset, int imageLength)(Code)
Creates an immutable image which is decoded from the data stored in the specified byte array at the specified offset and length. The data must be in a self-identifying image file format supported by the implementation, such as PNG.

The imageoffset and imagelength parameters specify a range of data within the imageData byte array. The imageOffset parameter specifies the offset into the array of the first data byte to be used. It must therefore lie within the range [0..(imageData.length-1)]. The imageLength parameter specifies the number of data bytes to be used. It must be a positive integer and it must not cause the range to extend beyond the end of the array. That is, it must be true that imageOffset + imageLength < imageData.length.

This method is intended for use when loading an image from a variety of sources, such as from persistent storage or from the network.


Parameters:
  imageData - the array of image data in a supported image format
Parameters:
  imageOffset - the offset of the start of the data in the array
Parameters:
  imageLength - the length of the data in the array the created image
throws:
  ArrayIndexOutOfBoundsException - if imageOffsetand imageLengthspecify an invalid range
throws:
  NullPointerException - if imageData isnull
throws:
  IllegalArgumentException - if imageData is incorrectlyformatted or otherwise cannot be decoded



createImage
public static Image createImage(Image image, int x, int y, int width, int height, int transform)(Code)
Creates an immutable image using pixel data from the specified region of a source image, transformed as specified.

The source image may be mutable or immutable. For immutable source images, transparency information, if any, is copied to the new image unchanged.

On some devices, pre-transformed images may render more quickly than images that are transformed on the fly using drawRegion. However, creating such images does consume additional heap space, so this technique should be applied only to images whose rendering speed is critical.

The transform function used must be one of the following, as defined in the javax.microedition.lcdui.game.Sprite Sprite class:
Sprite.TRANS_NONE - causes the specified image region to be copied unchanged
Sprite.TRANS_ROT90 - causes the specified image region to be rotated clockwise by 90 degrees.
Sprite.TRANS_ROT180 - causes the specified image region to be rotated clockwise by 180 degrees.
Sprite.TRANS_ROT270 - causes the specified image region to be rotated clockwise by 270 degrees.
Sprite.TRANS_MIRROR - causes the specified image region to be reflected about its vertical center.
Sprite.TRANS_MIRROR_ROT90 - causes the specified image region to be reflected about its vertical center and then rotated clockwise by 90 degrees.
Sprite.TRANS_MIRROR_ROT180 - causes the specified image region to be reflected about its vertical center and then rotated clockwise by 180 degrees.
Sprite.TRANS_MIRROR_ROT270 - causes the specified image region to be reflected about its vertical center and then rotated clockwise by 270 degrees.

The size of the returned image will be the size of the specified region with the transform applied. For example, if the region is 100 x 50 pixels and the transform is TRANS_ROT90, the returned image will be 50 x 100 pixels.

Note: If all of the following conditions are met, this method may simply return the source Image without creating a new one:

  • the source image is immutable;
  • the region represents the entire source image; and
  • the transform is TRANS_NONE.

Parameters:
  image - the source image to be copied from
Parameters:
  x - the horizontal location of the region to be copied
Parameters:
  y - the vertical location of the region to be copied
Parameters:
  width - the width of the region to be copied
Parameters:
  height - the height of the region to be copied
Parameters:
  transform - the transform to be applied to the region the new, immutable image
throws:
  NullPointerException - if image is null
throws:
  IllegalArgumentException - if the region to be copied exceedsthe bounds of the source image
throws:
  IllegalArgumentException - if either width orheight is zero or less
throws:
  IllegalArgumentException - if the transformis not valid



createImage
public static Image createImage(InputStream stream) throws java.io.IOException(Code)
Creates an immutable image from decoded image data obtained froH an InputStream. This method blocks until all image data has been read and decoded. After this method completes (whether by returning or by throwing an exception) the stream is left open and its current position is undefined.
Parameters:
  stream - the name of the resource containing the image datain one of the supported image formats the created image
throws:
  NullPointerException - if stream is null
throws:
  java.io.IOException - if an I/O error occurs, if the image datacannot be loaded, or if the image data cannot be decoded



createRGBImage
public static Image createRGBImage(int rgb, int width, int height, boolean processAlpha)(Code)
Creates an immutable image from a sequence of ARGB values, specified as 0xAARRGGBB. The ARGB data within the rgb array is arranged horizontally from left to right within each row, row by row from top to bottom. If processAlpha is true, the high-order byte specifies opacity; that is, 0x00RRGGBB specifies a fully transparent pixel and 0xFFRRGGBB specifies a fully opaque pixel. Intermediate alpha values specify semitransparency. If the implementation does not support alpha blending for image rendering operations, it must replace any semitransparent pixels with fully transparent pixels. (See Alpha Processing for further discussion.) If processAlpha is false, the alpha values are ignored and all pixels must be treated as fully opaque.

Consider P(a,b) to be the value of the pixel located at column a and row b of the Image, where rows and columns are numbered downward from the top starting at zero, and columns are numbered rightward from the left starting at zero. This operation can then be defined as:


 P(a, b) = rgb[a + b * width];    

for


 0 <= a < width
 0 <= b < height    


Parameters:
  rgb - an array of ARGB values that composes the image
Parameters:
  width - the width of the image
Parameters:
  height - the height of the image
Parameters:
  processAlpha - true if rgbhas an alpha channel,false if all pixels are fully opaque the created image
throws:
  NullPointerException - if rgb is null.
throws:
  IllegalArgumentException - if either width orheight is zero or less
throws:
  ArrayIndexOutOfBoundsException - if the length ofrgb isless than width * height.



getGraphics
public Graphics getGraphics()(Code)
Creates a new Graphics object that renders to this image. This image must be mutable; it is illegal to call this method on an immutable image. The mutability of an image may be tested with the isMutable() method.

The newly created Graphics object has the following properties:

  • the destination is this Image object;
  • the clip region encompasses the entire Image;
  • the current color is black;
  • the font is the same as the font returned by Font.getDefaultFont Font.getDefaultFont() ;
  • the stroke style is Graphics.SOLID SOLID ; and
  • the origin of the coordinate system is located at the upper-left corner of the Image.

The lifetime of Graphics objects created using this method is indefinite. They may be used at any time, by any thread.

a Graphics object with this image as its destination
throws:
  IllegalStateException - if the image is immutable



getHeight
public int getHeight()(Code)
Gets the height of the image in pixels. The value returned must reflect the actual height of the image when rendered. height of the image



getImageData
ImageData getImageData()(Code)
Returns ImageData associated with this Image. The ImageData associated with this Image.



getRGB
native public void getRGB(int[] rgbData, int offset, int scanlength, int x, int y, int width, int height)(Code)



getRomizedImage
static Image getRomizedImage(int imageDataArrayPtr, int imageDataArrayLength)(Code)
Function to load an romized Image.
Parameters:
  imageDataArrayPtr - native pointer to image data as Java int
Parameters:
  imageDataArrayLength - length of image data array image created. Null if no romized image matches the id.



getWidth
public int getWidth()(Code)
Gets the width of the image in pixels. The value returned must reflect the actual width of the image when rendered. width of the image



isMutable
public boolean isMutable()(Code)
Check if this image is mutable. Mutable images can be modified by rendering to them through a Graphics object obtained from the getGraphics() method of this object. true if the image is mutable,false otherwise



render
native boolean render(Graphics g, int x, int y, int anchor)(Code)
Renders this Image onto the provided Graphics object.
Parameters:
  g - the Graphics object to be rendered upon
Parameters:
  x - the x coordinate of the anchor point
Parameters:
  y - the y coordinate of the anchor point
Parameters:
  anchor - the anchor point for positioning the image false if anchor is not a legal value
See Also:   Graphics



renderRegion
native boolean renderRegion(Graphics g, int x_src, int y_src, int width, int height, int transform, int x_dest, int y_dest, int anchor)(Code)
Renders the specified region onto the provided Graphics object. ImmutableImage overrides this method so that the native implementation handles this appropriately.
Parameters:
  g - the Graphics object to be rendered upon
Parameters:
  x_src - the x coordinate of the upper left corner of the regionwithin the source image to copy
Parameters:
  y_src - the y coordinate of the upper left corner of the regionwithin the source image to copy
Parameters:
  width - the width of the region to copy
Parameters:
  height - the height of the region to copy
Parameters:
  transform - the desired transformation for the selected regionbeing copied
Parameters:
  x_dest - the x coordinate of the anchor point in thedestination drawing area
Parameters:
  y_dest - the y coordinate of the anchor point in thedestination drawing area
Parameters:
  anchor - the anchor point for positioning the region withinthe destination image false if src is the same image as thedestination of this Graphics object,or transform is invalid,or anchor is invalid,or the region to be copied exceeds the bounds of the source image.
See Also:   Graphics



resize
void resize(int width, int height, boolean keepContent)(Code)
Resize Image optionally saving its content clipped according to the new geometry
Parameters:
  width - new width of the Image
Parameters:
  height - new height of the Image
Parameters:
  keepContent - keep current content of the imagebinded to the (0, 0) of the resized image and clippedaccording to the new image dimensions



Methods inherited from java.lang.Object
public boolean equals(Object obj)(Code)(Java Doc)
final native public Class getClass()(Code)(Java Doc)
native public int hashCode()(Code)(Java Doc)
final native public void notify()(Code)(Java Doc)
final native public void notifyAll()(Code)(Java Doc)
public String toString()(Code)(Java Doc)
final native public void wait(long timeout) throws InterruptedException(Code)(Java Doc)
final public void wait(long timeout, int nanos) throws InterruptedException(Code)(Java Doc)
final public void wait() throws InterruptedException(Code)(Java Doc)

www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.