com.ccg.awt
Class ImageGen

java.lang.Object
  com.ccg.util.Convert
      com.ccg.awt.ImageGen

All Implemented Interfaces:

ImageGenerator

public class ImageGen
extends Convert
implements ImageGenerator

Implementation of a image generator This class is a full implementation of a ImageGenerator. It can interpret a series of "at commands" (things like "@fill(100,200,blue)" to produce and manipulate RGB bitmaps and produce a standard Java Image object.

This class provides several basic "at commands" which can be used directly. It is recommended to look at the ImageGenerator Class Overview which provides both a working interpreter (to allow you to try out some "at commands" as well as additional information on using and extending this class.

You use this class to build/modify bitmaps by passing a series of commands in as a String. The following code fragment demonstrates a primative way one could use this code (though this is not the normal/recommended way - it is suitable for documentation purposes):

 public static java.awt.Image redNoise() {
    ImageGen ig = new ImageGen();
    return ig.interpret(null,new ImageHolder(),
                        "@fill(200,100,red) @noise(70,130)");
 }
 

The following quick reference lists the "at commands" built into this class:

@fill(width,height,color)

This macro initializes (creates) a bitmap of the specified size and color. It should never appear accept as the first command to a set of macros as it completely replaces the existing bitmap (if there is one) with a new one.

@load(NAME[,x,y,w,h])

This macro is used to load the working pixels with a bitmap from the ImageHolder associated with the interpreter. You can optionally specify a rectangular region to load it only with a portion of a existing region (clip out a section of a bitmap).

@round(width[,strength[,smooth])

This macro rounds off the edges of the specified width of the bitmap. It can be used to create a button look.

@brightness(percent)

This macro is used to adjust the brightness of the pixels by a certain percentage (values above 100 increase brightness, and values below darken the image).

@contrast(a,p[,ga,gp,ba,bp])

This macro is used to adjust the contrast of each pixel by moving them towards or away from a specific "average value" (a). You need to pass either 2 or 6 arguments to this macro. If you pass two arguments, then all three color changes (RGB values) will be adjusted using the same parameters. If you pass 6 parameters, then the first pair (a,p) are used to adjust the red channel, the second pair (ga,gp) adjust the green channel and the third pair (ba,bp) adjust the blue channel. Adjustments are made with the following rules: If the percent value (p) is less than 100 [0,99], then the contrast will decrease and color values move towards the average. If you specify percentages larger than 100, then the contrast will increase as color values move away from the average. For example, if the red component of a pixel had a value of 10, and your desired average was 110, the distance from the current value to the desired average would be 100 (110-10). If you had specified a percent value of 90, then the new value for the color component would be 90% of 100 from the desired average of 110. This results in moving the color value from 10 to 20 (110-.9*100). Had you specified a percent value of 105, then the color value would have moved in the opposite direction to 5 (110 - 1.05*100).

@gray()

This macro converts the current bitmap to its gray scale representation (makes it like a black and white photo).

@noise([minper[,maxper]])

This macro randomly adjusts the brightness of each pixel by a random percentage within the range specified.

@hline(color,vofs[,sofs[,eofs]])

This macro can be used to draw a horizontal line on the bitmap.

@vline(color,hofs[,sofs[,eofs]])

This macro can be used to draw a vertical line on the bitmap.

Since:

1.0

Version:

$Revision: 1.9 $

Author:

$Author: pkb $

See Also:

ImageGenerator Class Overview

Constructor Summary

ImageGen()
Initializes object making it ready for use.

Method Summary

void	brightness() Adjust the brightness of the bitmap (lighten/darken) This method provides support for the "@brightness(percent)" macro.
protected void	checkArgCount(int required) Verifies a specific number of arguments were passed to the command.
protected Color	checkColor(String val, boolean allowDefault, Color defValue) Check that user specified a color value or allow a default.
protected int	checkInt(String val, boolean allowDefault, int defValue) Check that user specified a integer parameter or allow a default.
int	checkIntOrPercent(String val, int size, boolean allowDefault, int defValue) Handy method to convert a string to a bitmap position.
RGBPixels	checkRGBPixels() Fetch the working bitmap or error if one doesn't exist.
void	contrast() Adjust the contrast of the bitmap This method provides support for the "@contrast(percent)" macro.
void	fill() Create a new bitmap of a specific width, height and color This method provides support for the "@fill(width,height,color)" macro.
protected String	getArg(int idx) Get get one of the arguments which was passed to the @command.
protected int	getArgCount() Get the number of arguments passed to the command.
ImageHolder	getImageHolder() Get the ImageHolder to use as a repository for bitmap information
int	getLoadDelayMillis() Get how long to sleep after grabbing pixels (used by @load macro).
RGBPixels	getRGBPixels() Get the current RGBPixels object which we are modifying This method may return 'null' if the bitmap hasn't been created yet.
void	gray() Convert a color bitmap to black and white.
void	hline() Draw a horizontal line across the current bitmap.
Image	interpret(Object modify, ImageHolder ih, String commands) Interpret a set of commands to create/modify a image.
void	load() Load the working bitmap with a Image from the ImageHolder.
void	noise() Randomly adjust the brightness of the bitmap to give it a texture.
void	round() Create the affect of "rounding" the edges of the bitmap This method provides support for the "@round(width[,strength[,smooth])" macro.
void	setImageHolder(ImageHolder val) Set the ImageHolder to use as a repository for bitmap information
void	setLoadDelayMillis(int val) Set how long to sleep after grabbing pixels (used by @load macro).
void	setRGBPixels(RGBPixels val) Set the current RGBPixels object which we are modifying
void	vline() Draw a vertical line across the current bitmap.

Methods inherited from class com.ccg.util.Convert

choiceValue, getDateFormat, getNumberFormat, setDateFormat, setNumberFormat, toBoolean, toColor, toDate, toFont, toInputStream, toLocale, toNumber, toOutputStream, toString, toTimeSpan

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ImageGen

public ImageGen()

Initializes object making it ready for use.

Since:

1.0

See Also:

interpret(java.lang.Object, com.ccg.awt.ImageHolder, java.lang.String)

Method Detail

interpret

public Image interpret(Object modify,
                       ImageHolder ih,
                       String commands)
                throws Exception

Interpret a set of commands to create/modify a image. You have the following options when invoking this command:

• Pass a 'null' starting image with the assumption, requirement, that one of the first commands interpretted will create the image for you.
• Pass a starting image object assuming that the interpretor will be able to "apply" some affects to the object.

The string containing the set of commands to interpret must follow the rules specified in the ImageGenerator Class Overview document.

Specified by:

interpret in interface ImageGenerator

Parameters:

modify - This parameter can be any type of Java object, it will typically be 'null', a RGBPixels object, or some sort of Image object.

ih - This parameter serves as a way to provide a "library" of bitmap images to the interpreter. It should never be null, but its OK to pass a empty ImageHolder object. The interpreter is free to use this object to lookup additional bitmap resources as it builds its image.

commands - This is a set of commands which the interpreter understands to create/modify images.

Returns:

If the interpreter is able to successfully process the commands, it will return a Image object. It should never null - it throws an exception on failure.

Throws:

Exception

Since:

1.0

See Also:

ImageGenerator Class Overview

fill

public void fill()
          throws Exception

Create a new bitmap of a specific width, height and color This method provides support for the "@fill(width,height,color)" macro. It is invoked by the interpret command when it runs across a "@fill()" macro in the string it is parsing.

The macro has the following form:

@fill(width,height,color)

The following parameters are ALL required

width

A integer width (in pixels) for how wide to make the bitmap.

height

A integer height (in pixels) for how tall to make the bitmap.

color

A simple color name or integer RGB value for the color to use to fill the area with (as supported by the toColor method.

Throws:

Exception - If the arguments specified to the macro are not valid.

Since:

1.0

See Also:

interpret(java.lang.Object, com.ccg.awt.ImageHolder, java.lang.String)

load

public void load()
          throws Exception

Load the working bitmap with a Image from the ImageHolder. This method provides support for the "@load(name)" macro. It is invoked by the interpret command when it runs across a "@macro()" macro in the string it is parsing. This command is similar to the "@fill()" macro in that it "creates" a full working bitmap to manipulate (it doesn't modify anything - just replaces/creates). This means that the command should only used once at the start of the set of macros to process.

The macro can be invoked with either one or five arguments and has the following form:

@load(name)

@load(name,x,y,w,h)

name

This is the "name" of the Image object which to initialize our working pixel buffer with. The Image will be retrieved from the ImageHolder associated with the interpretor. If the image isn't found or fully loaded, a exception will be thrown.

x

This value is used to specify the offset from the left edge of the image to the rectangular area you want to clip from the loaded image. It can be specified as either a integer number of pixels, or as a percentage [0.0,1.0] of the image's width. Use negative values if you want to specify the location relative to the right edge instead of the left.

y

This value is used to specify the offset from the top edge of the image to the rectangular area you want to clip from the loaded image. It can be specified as either a integer number of pixels, or as a percentage [0.0,1.0] of the image's width. Use negative values if you want to specify the location relative to the bottom edge instead of the top.

w

This value is used to specify width of the rectangular area you wish to clip from the image. It can be specified as either a integer number of pixels, or as a percentage [0.0,1.0] of the image's width.

h

This value is used to specify height of the rectangular area you wish to clip from the image. It can be specified as either a integer number of pixels, or as a percentage [0.0,1.0] of the image's height.

Here are some examples:

The following would take load the image data whose top left corner was 10% in from left, and 10% down from the top. The size of the loaded image will be one half the width and height of the original:

 @load(megan,.1,.1,.5,.5)
 

The following would take load the image data whose top left corner was 30% in from left, and 10% up from the bottom. The size of the loaded image will be 10 pixels wide and 10 pixels tall:

 @load(megan,.3,-.1,10,10)
 

The following would load the image data whose top left corner was 100 pixels in from right, and 100 pixels up from the bottom. The size of the loaded image will be 100 pixels wide and 100 pixels tall:

 @load(megan,-100,-100,100,100)
 

Throws:

Exception - If the arguments specified to the macro are not valid, the associate ImageHolder doesn't contain the requested Image or the Image isn't fully loaded, or you tried to clip out a invalid region.

Since:

1.0

See Also:

fill()

round

public void round()
           throws Exception

Create the affect of "rounding" the edges of the bitmap This method provides support for the "@round(width[,strength[,smooth])" macro. It is invoked by the interpret command when it runs across a "@round()" macro in the string it is parsing. This macro behaves in a fashion similar to the RGBPixels.button3D(int, int) method, however, it also provides for the "smoothing" of the edges.

The macro has the following form:

@round(width[,strength[,smooth])

The following parameters are recognized:

width

A width for how wide of an edge to round - this parameter is REQUIRED and can not exceed half the width or height of the bitmap. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".2" it would use 20% of 50 pixels for a 10 pixel wide rounding area).

strength

A optional integer value which indicates how strong to make the shading (try values in the range of [-64,+64]). If omitted, it defaults to 20.

smooth

A optional integer value to indicate how smooth you want the rounded edges to be. If omitted, it defaults to 1 which results in the smoothest possible look. Values larger than 1 reduce the "smoothness", a value of 0 results in a beveled look.

Throws:

Exception - If there isn't a bitmap loaded to convert or if the arguments specified to the macro are not valid.

Since:

1.0

See Also:

RGBPixels.button3D(int, int)

hline

public void hline()
           throws Exception

Draw a horizontal line across the current bitmap. This method provides support for the "@hline(color,vofs[,sofs[,eofs]])" macro which allows one to draw a horizontal line on the bitmap. It is invoked by the interpret command when it runs across a "@hline()" macro in the string it is parsing.

The macro has the following form:

@hline(color,vofs[,sofs[,eofs]])

The following parameters are recognized:

color

A simple color name or integer RGB value for the color to use to draw the line with (as supported by the toColor method. This parameter is required.

vofs

A vertical offset from the top of the bitmap for the location of the horizontal line. This parameter is required. It must be in the range of [0,bitmap height - 1]. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".2" it would use 20% of 50 pixels for a 10 pixel offset). Negative values are measured from the bottom up. For example, "-10" on a 50 pixel tall bitmap would result in the line being drawn at row 40 of the bitmap.

sofs

A starting horizontal position for the line. This parameter is optional, if omitted it defaults to 0 (the left edge). If specified, it must be in the range of [0,bitmap width - 1]. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".2" it would use 20% of 50 pixels for a 10 pixel offset). Negative values are measured from the right side. For example, "-10" on a 200 pixel wide bitmap would result in the horizontal line starting 190 pixels in on the line.

eofs

A ending horizontal position for the line. This parameter is optional, if omitted it defaults to the width of the bitmap (the right edge). If specified, it must be in the range of [0,bitmap width-1]. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".8" it would use 80% of 50 pixels for a 40 pixel offset). Negative values are measured from the right side. For example, "-10" on a 200 pixel wide bitmap would result in the horizontal line ending 190 pixels from the left edge (10 pixels from the right).

Throws:

Exception - If there isn't a bitmap available to modify or if the arguments specified to the macro are not valid.

Since:

1.0

See Also:

vline()

vline

public void vline()
           throws Exception

Draw a vertical line across the current bitmap. This method provides support for the "@vline(color,vofs[,sofs[,eofs]])" macro which allows one to draw a vertical line on the bitmap. It is invoked by the interpret command when it runs across a "@vline()" macro in the string it is parsing.

The macro has the following form:

@vline(color,hofs[,sofs[,eofs]])

The following parameters are recognized:

color

A simple color name or integer RGB value for the color to use to draw the line with (as supported by the toColor method. This parameter is required.

hofs

A horizontal offset from the left edge for the location of the vertical line. This parameter is required. It must be in the range of [0,bitmap width - 1]. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".2" it would use 20% of 50 pixels for a 10 pixel offset). Negative values are measured from the right edge in. For example, "-10" on a 50 pixel wide bitmap would result in the line being drawn at column 40 of the bitmap (use "-1" to match the rightmost column).

sofs

A starting vertical position for the line. This parameter is optional, if omitted it defaults to 0 (the top edge). If specified, it must be in the range of [0,bitmap height - 1]. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".2" it would use 20% of 50 pixels for a 10 pixel offset). Negative values are measured from the bottom up. For example, "-10" on a 200 pixel tall bitmap would result in the vertical line starting 190 pixels from the top.

eofs

A ending vertical position for the line. This parameter is optional, if omitted it defaults to the height of the bitmap (the bottom). If specified, it must be in the range of [0,bitmap height]. You may specify a integer number of pixels or a fraction of the maximum allowed value (for example, if 50 pixels was the maximum allowed value and you passed ".8" it would use 80% of 50 pixels for a 40 pixel offset). Negative values are measured from the bottom. For example, "-10" on a 200 pixel tall bitmap would result in the vertical line ending 190 pixels from the top edge (10 pixels from the bottom).

Throws:

Exception - If there isn't a bitmap available to modify or if the arguments specified to the macro are not valid.

Since:

1.0

See Also:

hline()

brightness

public void brightness()
                throws Exception

Adjust the brightness of the bitmap (lighten/darken) This method provides support for the "@brightness(percent)" macro. It is invoked by the interpret command when it runs across a "@brightness()" macro in the string it is parsing. This macro behaves in a fashion similar to the RGBPixels.adjustBrightness(int) method.

The macro has the following form:

@brightness(percent)

The following parameters are recognized:

percent

A integer percentage value. Values in the range of [0,99] will darken the bitmap, whereas values larger than 100 will brighten it. This parameter is REQUIRED.

Throws:

Exception - If there isn't a bitmap loaded to convert or if the arguments specified to the macro are not valid.

Since:

1.0

See Also:

RGBPixels.adjustBrightness(int)

contrast

public void contrast()
              throws Exception

Adjust the contrast of the bitmap This method provides support for the "@contrast(percent)" macro. It is invoked by the interpret command when it runs across a "@contrast()" macro in the string it is parsing. This macro behaves in a fashion similar to the RGBPixels.adjustContrast(int) method.

The macro has the following form:

@contrast(percent)

The following parameters are recognized:

percent

A integer percentage value. Values in the range of [0,99] will reduce the contrast, whereas values larger than 100 will increase the contrast. This parameter is REQUIRED.

Throws:

Exception - If there isn't a bitmap loaded to convert or if the arguments specified to the macro are not valid.

Since:

1.0

See Also:

RGBPixels.adjustBrightness(int)

gray

public void gray()
          throws Exception

Convert a color bitmap to black and white. This method provides support for the "@gray()" macro. It is invoked by the interpret command when it runs across a "@gray()" macro in the string it is parsing. This macro behaves in a fashion similar to the RGBPixels.grayScale() method and changes a color bitmap to its gray scale equivalent.

The macro takes no paratmeters and has the following form:

@gray()

Throws:

Exception - If there isn't a bitmap loaded to convert.

Since:

1.0

See Also:

RGBPixels.grayScale()

noise

public void noise()
           throws Exception

Randomly adjust the brightness of the bitmap to give it a texture. This method provides support for the "@noise(minper,maxper)" macro. It is invoked by the interpret command when it runs across a "@noise()" macro in the string it is parsing. This macro behaves in a fashion similar to the RGBPixels.noise(int, int) method.

The macro has the following form:

@noise([minper[,maxper]])

The following parameters are recognized:

minper

The minimum value which the randomly generated percentage can take on. For example, a value of 60 would indicate that the brightness should never be adjusted below 60% for a single pixel. This parameter is optional and defaults to 80 if omitted.

maxper

The maximum value which the randomly generated percentage can take on. For example, a value of 120 would indicate that the brightness should never be adjusted above 120% for a single pixel. This parameter is optional and defaults to 120 if omitted.

Throws:

Exception - If there isn't a bitmap loaded to convert or if the arguments specified to the macro are not valid.

Since:

1.0

See Also:

RGBPixels.noise(int, int)

checkArgCount

protected void checkArgCount(int required)
                      throws Exception

Verifies a specific number of arguments were passed to the command. This method is used by the macro processing methods (like fill() to verify that the macro was invoked with the proper number of arguments. For example the @fill() macro requires 3 arguments, so it could invoke this method via: checkArgCount(3).

This method is typically only of interest to those wishing to extend the ImageGen class to provide additional macro commands. Refer to the ImageGenEx.java for an example of extending this class.

Throws:

Exception - An error indicating the the command was invoked with the incorrect number of arguments.

Since:

1.0

See Also:

getArgCount()

checkInt

protected int checkInt(String val,
                       boolean allowDefault,
                       int defValue)
                throws Exception

Check that user specified a integer parameter or allow a default. When a macro command needs a integer value which it wants the user to provide, this method can be used. This method takes care of converting the value supplied by the user or using a default value if the user omitted one. If the user specifies a invalid integer value, or omits the value and you require them to specify it, then the proper exception will be thrown.

If the user provided a valid integer, or the user omitted the value and you provided a default, the desired integer value will be returned to you.

This method is typically only of interest to those wishing to extend the ImageGen class to provide additional macro commands. Refer to the ImageGenEx.java for an example of extending this class.

Parameters:

val - The string value you want to convert (null is OK)

allowDefault - Set to true if you want to provide a default value if the "val" parameter is null. Set to false if you want to require that "val" can be evalutated as a integer.

defValue - If you allow a default value, then specify it here

Returns:

The integer value specified in the string (or as the default if the string was null).

Throws:

Exception - If we had to try and convert the "val" passed to a integer and it failed.

Since:

1.0

checkIntOrPercent

public int checkIntOrPercent(String val,
                             int size,
                             boolean allowDefault,
                             int defValue)
                      throws Exception

Handy method to convert a string to a bitmap position. This method takes a string value and converts it to integer value. However, it is designed especially for locating (x,y) coordinates on a bitmap. By passing the size of the bitmap (either the x or y dimension), this method can:

• Handle positive integer values and verify that the are in the range of [0,size-1]. For example "10" would be return 10.
• Handle negative integer values by treating them as offsets from the opposite edge (also range checks). For example, "-10" would return 90 if the size were 100.
• Handle floating point values as a percentage of the width. For example, ".5" would return 50 if the size were 100.

Parameters:

val - The string value you want to convert (null is OK)

size - The size of the bitmap (or range) you want to allow the resulting value to be within. The maximum value this method will return will be one less than this size (but at least 0).

allowDefault - Set to true if you want to provide a default value if the "val" parameter is null. Set to false if you want to require that "val" can be evalutated as a integer.

defValue - If you allow a default value, then specify it here

Returns:

The integer value specified in the string (or as the default if the string was null).

Throws:

Exception - If we had to try and convert the "val" passed to a integer and it failed.

Since:

1.0

See Also:

checkInt(java.lang.String, boolean, int)

checkColor

protected Color checkColor(String val,
                           boolean allowDefault,
                           Color defValue)
                    throws Exception

Check that user specified a color value or allow a default. When a macro command needs a color value which it wants the user to provide, this method can be used. This method takes care of converting the value supplied by the user or using a default value if provided. If the user specifies a invalid color value, or omits the value and you require them to specify it, then the proper exception will be thrown.

If the user provided a valid color value, or the user omitted the value and you provided a default, the desired color value will be returned to you.

This method is typically only of interest to those wishing to extend the ImageGen class to provide additional macro commands. Refer to the ImageGenEx.java for an example of extending this class.

Parameters:

val - The string value you want to convert (null is OK). Color values can be specified as integers or by a set of color names - refer to the color conversion method for more details.

allowDefault - Set to true if you want to provide a default value if the "val" parameter is null. Set to false if you want to require that "val" can be evalutated as a color value.

defValue - If you allow a default value, then specify it here

Returns:

The Color representation of the value specified in the string (or as the default if the string was null).

Throws:

Exception - If we had to try and convert the "val" passed to a color and it failed.

Since:

1.0

See Also:

Convert.toColor(java.lang.String, java.awt.Color)

checkRGBPixels

public RGBPixels checkRGBPixels()
                         throws Exception

Fetch the working bitmap or error if one doesn't exist. This method is designed to help support macros which require a working bitmap (ones that apply a filter of some sort). It verifies that a bitmap is available and returns access to it. If one isn't available, a semi-informative exception message is thrown.

Returns:

The current RGBPixels bitmap which one can apply a filter on.

Throws:

Exception - If a bitmap hasn't been created yet.

Since:

1.0

setImageHolder

public void setImageHolder(ImageHolder val)

Set the ImageHolder to use as a repository for bitmap information

Parameters:

val - New ImageHolder value to assign.

See Also:

getImageHolder()

getImageHolder

public ImageHolder getImageHolder()

Get the ImageHolder to use as a repository for bitmap information

Returns:

Current ImageHolder value assigned.

See Also:

setImageHolder(com.ccg.awt.ImageHolder)

setRGBPixels

public void setRGBPixels(RGBPixels val)

Set the current RGBPixels object which we are modifying

Parameters:

val - New RGBPixels value to assign.

See Also:

getRGBPixels()

getRGBPixels

public RGBPixels getRGBPixels()

Get the current RGBPixels object which we are modifying This method may return 'null' if the bitmap hasn't been created yet. Most interpeter commands will want to use the checkRGBPixels() method instead - which will throw an error if the bitmap hasn't been created yet.

This is this bitmap which a filter is free to change. Typically the filters will fetch the pixel array of the bitmap and adjust the contained pixels.

Returns:

Current RGBPixels value assigned.

See Also:

setRGBPixels(com.ccg.awt.RGBPixels)

getArg

protected String getArg(int idx)

Get get one of the arguments which was passed to the @command. This method returns a argument at the specified index for a invoked command. For example, if the command being interpretted was "@fill(200,100,red)", then getArg(0) would return "200", getArg(1) would return "100" and getArg(2) would return "red". If the user omitted the arg, then null would be returned (in our example, getArg(4) would return null).

Returns:

Current String value assigned.

See Also:

getArgCount()

getArgCount

protected int getArgCount()

Get the number of arguments passed to the command. Returns the number of arguments which the user invoked the @command with. For example, if the command being interpretted were: "@noise(70,130)", then getArgCount() would return 2.

Returns:

Number of arguments which were passed to the command.

Since:

1.0

See Also:

getArg(int)

setLoadDelayMillis

public void setLoadDelayMillis(int val)

Set how long to sleep after grabbing pixels (used by @load macro).

We came across a ugly problem in IE on a Windows NT server box where the JVM appeared to report that all of the pixels had been grabbed while processing a "@load" macro when in fact they had not. The array used to hold the pixels was then being overwritten later at a unknown time - this was a bad thing and made it appear as though the image processing macros were not being run.

To work around the problem, it was found that adding a simple "yield" after the fetch of each bitmap would help. This method can be used to adjust this sleep value. The values set are processed as follows:

Less Than Zero

Skips the work around (things go as quick as possible assuming that the JVM and system are working properly).

Zero

A thread yield will be done, but no sleeping will be done.

Greater Than Zero

The number specified will be treated as the number of milliseconds to sleep after each load.

Parameters:

val - New int value to assign as described above.

See Also:

getLoadDelayMillis()

getLoadDelayMillis

public int getLoadDelayMillis()

Get how long to sleep after grabbing pixels (used by @load macro).

Returns:

Current int value assigned (how many milliseconds to sleep).

See Also:

setLoadDelayMillis(int)