File	Doc	Category	Size	Date	Package
Gauge.java	API Doc	J2ME MIDP 2.0	51824	Thu Nov 07 12:02:26 GMT 2002	javax.microedition.lcdui

Gauge

• java.lang.Object
  • Item

Fields Summary
public static final int	INDEFINITE A special value used for the maximum value in order to indicate that the Gauge has indefinite range. This value may be used as the maxValue parameter to the constructor, the parameter passed to setMaxValue(), and as the return value of getMaxValue(). The value of INDEFINITE is -1.
public static final int	CONTINUOUS_IDLE The value representing the continuous-idle state of a non-interactive Gauge with indefinite range. In the continuous-idle state, the gauge shows a graphic indicating that no work is in progress. This value has special meaning only for non-interactive gauges with indefinite range. It is treated as an ordinary value for interactive gauges and for non-interactive gauges with definite range. The value of CONTINUOUS_IDLE is 0.
public static final int	INCREMENTAL_IDLE The value representing the incremental-idle state of a non-interactive Gauge with indefinite range. In the incremental-idle state, the gauge shows a graphic indicating that no work is in progress. This value has special meaning only for non-interactive gauges with indefinite range. It is treated as an ordinary value for interactive gauges and for non-interactive gauges with definite range. The value of INCREMENTAL_IDLE is 1.
public static final int	CONTINUOUS_RUNNING The value representing the continuous-running state of a non-interactive Gauge with indefinite range. In the continuous-running state, the gauge shows a continually-updating animation sequence that indicates that work is in progress. Once the application sets a gauge into the continuous-running state, the animation should proceed without further requests from the application. This value has special meaning only for non-interactive gauges with indefinite range. It is treated as an ordinary value for interactive gauges and for non-interactive gauges with definite range. The value of CONTINUOUS_RUNNING is 2.
public static final int	INCREMENTAL_UPDATING The value representing the incremental-updating state of a non-interactive Gauge with indefinite range. In the incremental-updating state, the gauge shows a graphic indicating that work is in progress, typically one frame of an animation sequence. The graphic should be updated to the next frame in the sequence only when the application calls setValue(INCREMENTAL_UPDATING). This value has special meaning only for non-interactive gauges with indefinite range. It is treated as an ordinary value for interactive gauges and for non-interactive gauges with definite range. The value of INCREMENTAL_UPDATING is 3.
private javax.microedition.lcdui.game.Sprite	spriteInUse Current sprite in use...continuous or incremental If null, the initSprites() has not been called
private javax.microedition.lcdui.game.Sprite	INCREMENTAL_SPRITE Sprite used for the incremental indefinite gauge animation.
private javax.microedition.lcdui.game.Sprite	CONTINUOUS_SPRITE Sprite used for the continuous indefinite gauge animation.
private static final Image	LEFTARROW_IMG Image for the left arrow.
private static final Image	RIGHTARROW_IMG Image for the right arrow.
private static final Image	INCREMENTAL_IMG Sprite image for frames of an incremental indefinite gauge.
private static final Image	CONTINUOUS_IMG Sprite image for frames of an continuous indefinite gauge.
private static final int[]	IDLE_SEQUENCE Frame sequence for an idle indefinite gauge.
private static final int[]	ACTIVE_SEQUENCE Frame sequence for a non idle indefinite gauge.
private int	value The current value of this gauge
private int	maxValue The maximum possible value of this gauge
private boolean	interactive Wether this gauge is interactive or not
private int	blockCount The number of blocks making up this gauge
private boolean	traversedIn A flag indicating a prior call to callTraverse()
private static final int	DEFAULT_WIDTH By default, a Gauge is 78 pixels wide
private static final int	BLOCK_SPACE The space occupied by one block in the gauge.
private static final int	GAUGE_HEIGHT Greatest height, in pixels, this gauge will occupy on screen
private int	valueOfEachBlock The numerical value assigned to each block. The number of blocks (blockCount) times the value of each block (valueOfEachBlock) shall equal the maximum value of this gauge (maxValue) In the case of an indefinite range gauge, the number of blocks (blockCount) will equal the "maximum value" of the gauge (frameCount) and valueOfEachBlock will be 1.
private boolean	drawLeftArrow Whether we draw the left arrow or not.
private boolean	drawRightArrow Whether we draw the right arrow or not.
private int	arrowWidth Arrow width - space available for the arrows.
private int	blockMargin The buffer of horizontal space to split on either side of this gauge (creating left/right margins)
private static Timer	gaugeUpdateTimer A Timer which will handle scheduling repaints of an indefinite range gauge when value == CONTINUOUS_RUNNING
private GaugeUpdateTask	updateHelper A TimerTask which will schedule repaints of an indefinite range gauge when value == CONTINUOUS_RUNNING

Constructors Summary

public Gauge(String label, boolean interactive, int maxValue, int initialValue) Creates a new Gauge object with the given label, in interactive or non-interactive mode, with the given maximum and initial values. In interactive mode (where interactive is true) the maximum value must be greater than zero, otherwise an exception is thrown. In non-interactive mode (where interactive is false) the maximum value must be greater than zero or equal to the special value INDEFINITE, otherwise an exception is thrown. If the maximum value is greater than zero, the gauge has definite range. In this case the initial value must be within the range zero to maxValue, inclusive. If the initial value is less than zero, the value is set to zero. If the initial value is greater than maxValue, it is set to maxValue. If interactive is false and the maximum value is INDEFINITE, this creates a non-interactive gauge with indefinite range. The initial value must be one of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING. see #INDEFINITE see #CONTINUOUS_IDLE see #INCREMENTAL_IDLE see #CONTINUOUS_RUNNING see #INCREMENTAL_UPDATING param label the Gauge's label param interactive tells whether the user can change the value param maxValue the maximum value, or INDEFINITE param initialValue the initial value in the range [0..maxValue], or one of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING if maxValue is INDEFINITE. throws IllegalArgumentException if maxValue is not positive for interactive gauges throws IllegalArgumentException if maxValue is neither positive nor INDEFINITE for non-interactive gauges throws IllegalArgumentException if initialValue is not one of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING for a non-interactive gauge with indefinite range super(label); if (maxValue == INDEFINITE && (initialValue < CONTINUOUS_IDLE || initialValue > INCREMENTAL_UPDATING)) { throw new IllegalArgumentException(); } synchronized (Display.LCDUILock) { this.interactive = interactive; if (this.interactive) { arrowWidth = LEFTARROW_IMG.getWidth() + 6; // this spacing is what is aesthitically suitable } else { arrowWidth = 0; } blockMargin = 2 + arrowWidth; /* * IllegalArgumentException may be thrown by * setMaxValueImpl and setValue */ setMaxValueImpl(maxValue); setValue(initialValue); }

Methods Summary
public void	addCommand(Command cmd) Adds a context sensitive Command to the item. The semantic type of Command should be ITEM. The implementation will present the command only when the the item is active, for example, highlighted. If the added command is already in the item (tested by comparing the object references), the method has no effect. If the item is actually visible on the display, and this call affects the set of visible commands, the implementation should update the display as soon as it is feasible to do so. It is illegal to call this method if this Item is contained within an Alert. param cmd the command to be added throws IllegalStateException if this Item is contained within an Alert throws NullPointerException if cmd is null since MIDP 2.0 if (this.owner instanceof Alert) { throw new IllegalStateException("Gauge contained within an Alert"); } super.addCommand(cmd);
void	callHideNotify() Called by the system to notify this Item it is being hidden The default implementation of this method updates the 'visible' state if (updateHelper != null) { cancelGaugeUpdateTask(); } this.visible = false;
int	callMinimumHeight() Return the minimum height for this gauge return the minimum height return callPreferredHeight(-1);
int	callMinimumWidth() Return the minimum width for this guage return the minimum width return DEFAULT_WIDTH;
void	callPaint(Graphics g, int w, int h) Paint the contents of this gauge param g the graphics to paint to param w the width of this gauge param h the height of this gauge if (blockCount == -1) { setBlockCountAndValue(w); } int clipX = g.getClipX(); // We need to check the clip to determine if // the label needs painting int labelHeight = super.paintLabel(g, w); g.translate(0, labelHeight); if (maxValue == INDEFINITE) { spriteInUse.paint(g); } else { int RGBdrawColor; if (hasFocus) { RGBdrawColor = Display.FG_COLOR; } else { g.setColor(0x00606060); // dark gray // Keep in mind that on a 1-bit display, dark gray will // round to black RGBdrawColor = 0x00606060; } // setup the scroll arrows. setGaugeArrows(); // paint left arrow if necessary. if (interactive) { // check clip boundaries. if (clipX < blockMargin) { if (drawLeftArrow) { g.drawImage(LEFTARROW_IMG, // (BLOCK_SPACE / 2) + (arrowWidth / 2), 2, GAUGE_HEIGHT / 2, Graphics.LEFT | Graphics.VCENTER); } else { g.setColor(Display.ERASE_COLOR); g.fillRect(0, // BLOCK_SPACE / 2, 2, arrowWidth, GAUGE_HEIGHT); g.setColor(RGBdrawColor); } } } // Depending on the clip, we may need to repaint // only some or all of the blocks. int startBlock = blockCount; int stopBlock = blockCount; if (clipX - blockMargin < (blockCount * BLOCK_SPACE)) { startBlock = (clipX - blockMargin) / BLOCK_SPACE; // we don't want a startBlock < 0 // (which happens if the clip is off to the left) startBlock = startBlock < 0 ? 0 : startBlock; // only when we have calculated a startBlock // do we want to calculate a stopBlock if (clipX + g.getClipWidth() > blockMargin) { stopBlock = (clipX + g.getClipWidth() - blockMargin) / BLOCK_SPACE; stopBlock ++; // increment so that we take care of // a clip x-coord in the middle // of a block // we don't want a startBlock < 0 // (which happens if the clip is off to the left) stopBlock = stopBlock > blockCount ? blockCount : stopBlock; } } // these values are used in calculating the blockHeight // they only need to be calculated once every paint int bc = blockCount - 1; int bc2 = bc * bc; for (int i = startBlock; i < stopBlock; i++) { int blockHeight = GAUGE_HEIGHT; if (interactive && blockCount > 1) { // // this implements a quadratic spline from // p0 to p2 using p1 as a control point to // affect the curve // // int p0 = 5, // minimum height // p1 = 1, // control point // p2 = GAUGE_HEIGHT - p0; // maximum height // // the original equation is below, but the one used // has been expanded to use the p values above // // blockHeight = p0 + // (2 * p1 * i * (bc - i) / bc2) + // ((p2 * (i * i)) / bc2); // blockHeight = 5 + (((i * (bc - i)) << 1) / bc2) + (((GAUGE_HEIGHT - 5) * (i * i)) / bc2); } if ((valueOfEachBlock * (i + 1)) > value && value != maxValue) { if (hasFocus) { g.drawRect(blockMargin + (i * BLOCK_SPACE), GAUGE_HEIGHT - blockHeight, BLOCK_SPACE - 3, blockHeight); } else { g.setStrokeStyle(Graphics.DOTTED); g.drawRect(blockMargin + (i * BLOCK_SPACE), GAUGE_HEIGHT - blockHeight, BLOCK_SPACE - 3, blockHeight); g.setStrokeStyle(Graphics.SOLID); } } else { // // + 1 on the width and height so that // the blocks look the size if they are // empty or filled // g.fillRect(blockMargin + (i * BLOCK_SPACE), GAUGE_HEIGHT - blockHeight, BLOCK_SPACE - 3 + 1, blockHeight + 1); } } if (interactive) { if (drawRightArrow == true) { g.drawImage(RIGHTARROW_IMG, blockMargin + ((blockCount)*BLOCK_SPACE) + (arrowWidth / 2), GAUGE_HEIGHT / 2, Graphics.HCENTER | Graphics.VCENTER); } else { g.setColor(Display.ERASE_COLOR); g.fillRect(blockMargin + ((blockCount)*BLOCK_SPACE) + (arrowWidth / 2), 0, arrowWidth, GAUGE_HEIGHT); g.setColor(RGBdrawColor); } } if (!hasFocus) { g.setColor(Display.FG_COLOR); } } // max value != INDEFINITE g.translate(0, -labelHeight);
int	callPreferredHeight(int w) Get the preferred height for this gauge for the given width param w the width to compute the height for return the height preferred for the given width if (maxValue == INDEFINITE) { return INCREMENTAL_SPRITE.getHeight() + getLabelHeight(w); } else { // NTS: Don't know why the '+2' is needed return GAUGE_HEIGHT + getLabelHeight(w) + 2; }
int	callPreferredWidth(int h) Return the preferred width for this gauge for the given height param h the height to compute the width for return the preferred width for the given height return DEFAULT_WIDTH;
void	callShowNotify() Called by the system to notify this Item it is being shown The default implementation of this method updates the 'visible' state if (maxValue == INDEFINITE && value == CONTINUOUS_RUNNING && updateHelper == null) { setValue(CONTINUOUS_RUNNING); } this.visible = true;
boolean	callTraverse(int dir, int viewportWidth, int viewportHeight, int[] visRect) Handle traversal within this Gauge param dir the direction of traversal param viewportWidth the width of the viewport param viewportHeight the height of the viewport param visRect the in/out rectangle for the internal traversal location return True if traversal occurred within this Gauge super.callTraverse(dir, viewportWidth, viewportHeight, visRect); if (!traversedIn) { traversedIn = true; return true; } else if (interactive) { switch (dir) { case Canvas.LEFT: case Canvas.RIGHT: modifyValue(dir); return true; case Canvas.UP: case Canvas.DOWN: return false; } } return false;
void	callTraverseOut() Traverse out of this Gauge super.callTraverseOut(); traversedIn = false;
private void	cancelGaugeUpdateTask() Stop the GaugeUpdateTask from running. if (updateHelper != null) { updateHelper.cancel(); updateHelper = null; }
private void	checkValue() Utility method to ensure the value of the Gauge is always in a range of 0 to maxValue, or if maxValue is INDEFINITE that value is CONTINUOUS_IDLE, INCREMENTAL_IDLE, INCREMENTAL_UPDATING, or CONTINUOUS_RUNNING. In the case where maxValue is INDEFINITE and value is not one of the three defined here it will be set to CONTINUOUS_IDLE. (0) private instanve variable value will be within parameter after this call if (maxValue == INDEFINITE) { if (value < CONTINUOUS_IDLE || value > INCREMENTAL_UPDATING) { value = CONTINUOUS_IDLE; } } else { if (value < 0) { value = 0; } else if (value > maxValue) { value = maxValue; } }
boolean	equateNLA() Determine if this Item should have a newline after it return true if it should have a newline after if (super.equateNLA()) { return true; } return ((layout & Item.LAYOUT_2) != Item.LAYOUT_2);
boolean	equateNLB() Determine if this Item should have a newline before it return true if it should have a newline before if (super.equateNLB()) { return true; } return ((layout & Item.LAYOUT_2) != Item.LAYOUT_2);
public int	getMaxValue() Gets the maximum value of this Gauge object. If this gauge is interactive, the maximum value will be a positive integer. If this gauge is non-interactive, the maximum value will be a positive integer (indicating that the gauge has definite range) or the special value INDEFINITE (indicating that the gauge has indefinite range). see #INDEFINITE return the maximum value of the Gauge, or INDEFINITE see #setMaxValue // SYNC NOTE: return of atomic value, no locking necessary return maxValue;
public int	getValue() Gets the current value of this Gauge object. If this Gauge object is a non-interactive gauge with indefinite range, the value returned will be one of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING. Otherwise, it will be an integer between zero and the gauge's maximum value, inclusive. see #CONTINUOUS_IDLE see #INCREMENTAL_IDLE see #CONTINUOUS_RUNNING see #INCREMENTAL_UPDATING return current value of the Gauge see #setValue // SYNC NOTE: return of atomic value, no locking necessary return value;
private void	initSprites() In cases where this gauge is used in an INDEFINITE mode we need these sprites around. INCREMENTAL_SPRITE = new Sprite(INCREMENTAL_IMG, 44, 45); CONTINUOUS_SPRITE = new Sprite(CONTINUOUS_IMG, 29, 33);
public boolean	isInteractive() Tells whether the user is allowed to change the value of the Gauge. return a boolean indicating whether the Gauge is interactive // SYNC NOTE: return of atomic value, no locking necessary return interactive;
void	modifyValue(int dir) Possibly handle a value change param dir the direction key the user pressed to change the value Form form = null; synchronized (Display.LCDUILock) { // There are two cases where we need to repaint a // block when a user changes a Gauge's value: // 1. If the user is increasing the Gauge's value // and the value increases such that a new bar // needs to be filled in. The easy test for this // is: value % valueOfEachBlock == 0, indicating // the value has increased precisely enough to // fill in an entire block. // // 2. If the user is decreasing the Gauge's value // and the value decreases such that a currently // filled in bar needs to be un-filled. The easy // test for this is: // (value + 1) % valueOfEachBlock == 0, indicating // we have just decreased 1 unit below a full // block. int blockToRepaint = -1; int oldValue = value; if (dir == Canvas.LEFT) { if (value % valueOfEachBlock == 0) { blockToRepaint = (value / valueOfEachBlock) - 1; } else if (value == maxValue) { blockToRepaint = blockCount - 1; } value--; } else { value++; if (value % valueOfEachBlock == 0) { blockToRepaint = (value / valueOfEachBlock) - 1; } else if (value == maxValue) { blockToRepaint = blockCount - 1; } } checkValue(); // Because of the necessity to call repaintImpl() // in case of boundary conditions also, // we always call repaintImpl() // Avoids artefacts caused by not refreshing the arrows. // We need to remember to offset by the height of our // label if there is one. int blockY = getLabelHeight(bounds[WIDTH]); // Cause a repaintImpl // of the blocks if (blockToRepaint < blockCount) { repaint(blockMargin + (blockToRepaint * BLOCK_SPACE), blockY, BLOCK_SPACE, GAUGE_HEIGHT + 2); } // of the left arrow if (blockToRepaint <= 0) { repaint(2, blockY, arrowWidth, GAUGE_HEIGHT); } // of the right arrow if (blockToRepaint >= blockCount - 1) { repaint(blockMargin + (blockCount * BLOCK_SPACE), blockY, arrowWidth, GAUGE_HEIGHT); } if (value != oldValue) { // notify the ItemStateChangedListener form = (Form)this.getOwner(); } } // end synchronized // SYNC NOTE: We make sure we notify the ItemStateChangedListener // outside of our lock if (form != null) { form.itemStateChanged(this); }
private void	setBlockCountAndValue(int width) Set the value of each block. This will use the blockCount value and maxValue to assign a value to each block. param width the width given to this gauge on the screen blockCount = (width - (2 * arrowWidth)) / (BLOCK_SPACE); if (maxValue != INDEFINITE) { if (blockCount > maxValue) { blockCount = maxValue; } valueOfEachBlock = 1; if (maxValue <= blockCount) { return; } try { valueOfEachBlock = maxValue / blockCount; if (maxValue % blockCount != 0) { valueOfEachBlock++; } // There's a case when our max is close to // a multiple of our value per block (ie 50 // as a max value, 4 or 5 as a value per block). // In this case, we decrease the number of blocks // and make each block an even value // (5, using the above example). blockCount = maxValue / valueOfEachBlock; if (maxValue % valueOfEachBlock != 0) { blockCount++; } // If the max was a value like 52, then there // would be the full number of blocks (11 with // the RI screen width) and the last block // would have 2 units of value. The last block // in the gauge always as as many or less units // than the other blocks in the gauge. } catch (ArithmeticException e) { // width could be set to 0. // in which case an aritmetic exception // might be thrown } }
public void	setDefaultCommand(Command cmd) Sets default Command for this Item. If the Item previously had a default Command, that Command is no longer the default, but it remains present on the Item. If not null, the Command object passed becomes the default Command for this Item. If the Command object passed is not currently present on this Item, it is added as if {@link #addCommand} had been called before it is made the default Command. If null is passed, the Item is set to have no default Command. The previous default Command, if any, remains present on the Item. It is illegal to call this method if this Item is contained within an Alert. param cmd the command to be used as this Item's default Command, or null if there is to be no default command throws IllegalStateException if this Item is contained within an Alert since MIDP 2.0 if (this.owner instanceof Alert) { throw new IllegalStateException("Gauge contained within an Alert"); } super.setDefaultCommand(cmd);
private void	setGaugeArrows() Set the horizontal arrows for this gauge. we are turning on the left/right indicator arrows on the display to indicate to the user that the Gauge can be incremented/decremented. // If we have focus and are interactive, we check // to see if we need to add the right or left arrow // arrow should only // appear when the gauge has focus if ((hasFocus) && (interactive)) { int scrollPosition = value * 100 / maxValue; // Fix the rounding error if (value > 0 && scrollPosition == 0) { scrollPosition = 1; } if (0 < value && value < maxValue) { drawLeftArrow = drawRightArrow = true; } else { if (value == 0) { drawLeftArrow = false; drawRightArrow = true; } else { drawLeftArrow = true; drawRightArrow = false; } } } else { drawLeftArrow = drawRightArrow = false; }
public void	setItemCommandListener(ItemCommandListener l) Sets a listener for Commands to this Item, replacing any previous ItemCommandListener. A null reference is allowed and has the effect of removing any existing listener. It is illegal to call this method if this Item is contained within an Alert. param l the new listener, or null. throws IllegalStateException if this Item is contained within an Alert since MIDP 2.0 if (this.owner instanceof Alert) { throw new IllegalStateException("Gauge contained within an Alert"); } super.setItemCommandListener(l);
public void	setLabel(java.lang.String label) Sets the label of the Item. If label is null, specifies that this item has no label. It is illegal to call this method if this Item is contained within an Alert. param label the label string throws IllegalStateException if this Item is contained within an Alert see #getLabel if (this.owner instanceof Alert) { throw new IllegalStateException("Gauge contained within an Alert"); } super.setLabel(label);
public void	setLayout(int layout) Sets the layout directives for this item. It is illegal to call this method if this Item is contained within an Alert. param layout a combination of layout directive values for this item throws IllegalArgumentException if the value of layout is not a valid combination of layout directives throws IllegalStateException if this Item is contained within an Alert since MIDP 2.0 see #getLayout if (this.owner instanceof Alert) { throw new IllegalStateException("Gauge contained within an Alert"); } super.setLayout(layout);
public void	setMaxValue(int maxValue) Sets the maximum value of this Gauge object. For interactive gauges, the new maximum value must be greater than zero, otherwise an exception is thrown. For non-interactive gauges, the new maximum value must be greater than zero or equal to the special value INDEFINITE, otherwise an exception is thrown. If the new maximum value is greater than zero, this provides the gauge with a definite range. If the gauge previously had a definite range, and if the current value is greater than new maximum value, the current value is set to be equal to the new maximum value. If the gauge previously had a definite range, and if the current value is less than or equal to the new maximum value, the current value is left unchanged. If the new maximum value is greater than zero, and if the gauge had previously had indefinite range, this new maximum value provides it with a definite range. Its graphical representation must change accordingly, the previous state of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING is ignored, and the current value is set to zero. If this gauge is non-interactive and the new maximum value is INDEFINITE, this gives the gauge indefinite range. If the gauge previously had a definite range, its graphical representation must change accordingly, the previous value is ignored, and the current state is set to CONTINUOUS_IDLE. If the gauge previously had an indefinite range, setting the maximum value to INDEFINITE will have no effect. see #INDEFINITE param maxValue the new maximum value throws IllegalArgumentException if maxValue is invalid see #getMaxValue synchronized (Display.LCDUILock) { setMaxValueImpl(maxValue); }
private void	setMaxValueImpl(int maxValue) Set the max value of this Gauge. param maxValue The maximum value to set for this Gauge throws IllegalArgumentException if maxValue is not positive for interactive gauges throws IllegalArgumentException if maxValue is neither positive nor INDEFINITE for non-interactive gauges if (maxValue <= 0) { if (!(interactive == false && maxValue == INDEFINITE)) { throw new IllegalArgumentException(); } } int oldMaxValue = this.maxValue; this.maxValue = maxValue; if (oldMaxValue == INDEFINITE) { if (maxValue > INDEFINITE) { value = 0; blockCount = -1; // signal to recalculate blockCount } } else { if (maxValue == INDEFINITE) { value = CONTINUOUS_IDLE; if (spriteInUse == null) { initSprites(); } spriteInUse = CONTINUOUS_SPRITE; spriteInUse.setFrameSequence(IDLE_SEQUENCE); } } checkValue(); // // changing the max value will change the scale and how many // solid blocks are drawn. setting blockCount to -1 will force // callPaint to recalculate how much each block is worth. // blockCount = -1; invalidate();
public void	setPreferredSize(int width, int height) Sets the preferred width and height for this Item. Values for width and height less than -1 are illegal. If the width is between zero and the minimum width, inclusive, the minimum width is used instead. If the height is between zero and the minimum height, inclusive, the minimum height is used instead. Supplying a width or height value greater than the minimum width or height locks that dimension to the supplied value. The implementation may silently enforce a maximum dimension for an Item based on factors such as the screen size. Supplying a value of -1 for the width or height unlocks that dimension. See Item Sizes for a complete discussion. It is illegal to call this method if this Item is contained within an Alert. param width the value to which the width should be locked, or -1 to unlock param height the value to which the height should be locked, or -1 to unlock throws IllegalArgumentException if width or height is less than -1 throws IllegalStateException if this Item is contained within an Alert see #getPreferredHeight see #getPreferredWidth since MIDP 2.0 if (this.owner instanceof Alert) { throw new IllegalStateException("Gauge contained within an Alert"); } super.setPreferredSize(width, height);
public void	setValue(int value) Sets the current value of this Gauge object. If the gauge is interactive, or if it is non-interactive with definite range, the following rules apply. If the value is less than zero, zero is used. If the current value is greater than the maximum value, the current value is set to be equal to the maximum value. If this Gauge object is a non-interactive gauge with indefinite range, then value must be one of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING. Other values will cause an exception to be thrown. see #CONTINUOUS_IDLE see #INCREMENTAL_IDLE see #CONTINUOUS_RUNNING see #INCREMENTAL_UPDATING param value the new value throws IllegalArgumentException if value is not one of CONTINUOUS_IDLE, INCREMENTAL_IDLE, CONTINUOUS_RUNNING, or INCREMENTAL_UPDATING for non-interactive gauges with indefinite range see #getValue synchronized (Display.LCDUILock) { if (!interactive && maxValue == INDEFINITE) { if (value != CONTINUOUS_RUNNING && this.value == CONTINUOUS_RUNNING) { cancelGaugeUpdateTask(); } switch (value) { case CONTINUOUS_IDLE: spriteInUse = CONTINUOUS_SPRITE; spriteInUse.setFrameSequence(IDLE_SEQUENCE); break; case INCREMENTAL_IDLE: spriteInUse = INCREMENTAL_SPRITE; spriteInUse.setFrameSequence(IDLE_SEQUENCE); break; case INCREMENTAL_UPDATING: if (spriteInUse != INCREMENTAL_SPRITE || spriteInUse.getFrameSequenceLength() == 1) { spriteInUse = INCREMENTAL_SPRITE; spriteInUse.setFrameSequence(ACTIVE_SEQUENCE); } else { spriteInUse.nextFrame(); } break; case CONTINUOUS_RUNNING: if (spriteInUse != CONTINUOUS_SPRITE || spriteInUse.getFrameSequenceLength() == 1) { spriteInUse = CONTINUOUS_SPRITE; spriteInUse.setFrameSequence(ACTIVE_SEQUENCE); } if (updateHelper == null) { startGaugeUpdateTask(spriteInUse); } break; default: throw new IllegalArgumentException(); } } this.value = value; checkValue(); repaint(); }
private void	startGaugeUpdateTask(javax.microedition.lcdui.game.Sprite sprite) Start the GaugeUpdateTask running param sprite the sprite to pass to the GaugeUpdateTask constructor updateHelper = new GaugeUpdateTask(sprite, this); gaugeUpdateTimer.schedule(updateHelper, 250, 250);