Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* MicroEmulator
* Copyright (C) 2001 Bartek Teodorczyk
* Copyright (C) 2005 Andres Navarro
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contributor(s):
* 3GLab
*/
package javax.microedition.lcdui;
public class Gauge extends Item
{
static int HEIGHT = 15;
int value;
int maxValue;
boolean interactive;
public static final int INDEFINITE = -1;
public static final int CONTINUOUS_IDLE = 0;
public static final int INCREMENTAL_IDLE = 1;
public static final int CONTINUOUS_RUNNING = 2;
public static final int INCREMENTAL_UPDATING = 3;
// these are for render of indefinite running and
// updating gauges
private int indefiniteFrame;
private static final int IDEFINITE_FRAMES = 4;
// package access for access from Display
static int PAINT_TIMEOUT = 500;
// package access to allow reading from Alert
int prefWidth, prefHeight;
public Gauge(String label, boolean interactive, int maxValue, int initialValue)
{
super(label);
this.interactive = interactive;
setMaxValue(maxValue);
setValue(initialValue);
}
public void setValue(int value)
{
if (hasIndefiniteRange()) {
if (value != Gauge.CONTINUOUS_IDLE &&
value != Gauge.CONTINUOUS_RUNNING &&
value != Gauge.INCREMENTAL_IDLE &&
value != Gauge.INCREMENTAL_UPDATING) {
throw new IllegalArgumentException();
} else {
// TODO if CONTINOUS_RUNNING
// start thread or whatever it needs to be done
if (value == Gauge.INCREMENTAL_UPDATING &&
this.value == Gauge.INCREMENTAL_UPDATING) {
updateIndefiniteFrame();
} else {
this.value = value;
repaint();
}
}
} else {
if (value < 0) {
value = 0;
}
if (value > maxValue) {
value = maxValue;
}
this.value = value;
repaint();
}
}
public int getValue()
{
return value;
}
public void setMaxValue(int maxValue)
{
if (maxValue > 0) {
this.maxValue = maxValue;
setValue(getValue());
} else {
if (isInteractive()) {
throw new IllegalArgumentException();
} else if (maxValue != Gauge.INDEFINITE) {
throw new IllegalArgumentException();
} else {
// not interactive && maxValue == INDEFINITE
// this is also the case in the
// first call in the constructor!
if (this.maxValue == Gauge.INDEFINITE) {
return;
} else {
this.maxValue = Gauge.INDEFINITE;
this.value = Gauge.INCREMENTAL_IDLE;
repaint();
}
}
}
}
public int getMaxValue()
{
return maxValue;
}
public boolean isInteractive()
{
return interactive;
}
// package access for access from Display
boolean hasIndefiniteRange() {
return ((!isInteractive()) &&
(getMaxValue() == Gauge.INDEFINITE));
}
// package access for access from Display
void updateIndefiniteFrame() {
if (hasIndefiniteRange() &&
((getValue() == Gauge.CONTINUOUS_RUNNING) ||
(getValue() == Gauge.INCREMENTAL_UPDATING))) {
if (indefiniteFrame+1 < Gauge.IDEFINITE_FRAMES)
indefiniteFrame++;
else
indefiniteFrame = 0;
repaint();
}
}
// ITEM methods
int getHeight()
{
return super.getHeight() + HEIGHT;
}
boolean isFocusable()
{
return interactive;
}
void keyPressed(int keyCode)
{
if (Display.getGameAction(keyCode) == Canvas.LEFT && value > 0) {
value--;
repaint();
} else if (Display.getGameAction(keyCode) == Canvas.RIGHT && value < maxValue) {
value++;
repaint();
}
}
int paint(Graphics g)
{
super.paintContent(g);
g.translate(0, super.getHeight());
if (hasFocus()) {
g.drawRect(2, 2, owner.getWidth() - 5, HEIGHT - 5);
}
if (hasIndefiniteRange()) {
if (getValue() == Gauge.CONTINUOUS_IDLE ||
getValue() == Gauge.INCREMENTAL_IDLE) {
int width = owner.getWidth() - 9;
g.drawRect(4, 4, width, HEIGHT - 9);
} else {
int width = ((owner.getWidth() - 8) << 1) / Gauge.IDEFINITE_FRAMES;
int offset = (width >>> 1) * indefiniteFrame;
int width2 = 0;
if (offset + width > (owner.getWidth() - 8)) {
width2 = offset + width - (owner.getWidth() - 8);
width -= width2;
}
g.fillRect(4 + offset, 4, width, HEIGHT - 8);
if (width2 != 0) {
g.fillRect(4, 4, width2, HEIGHT - 8);
}
}
} else {
int width = (owner.getWidth() - 8) * value / maxValue;
g.fillRect(4, 4, width, HEIGHT - 8);
}
g.translate(0, -super.getHeight());
return getHeight();
}
int traverse(int gameKeyCode, int top, int bottom, boolean action)
{
if (gameKeyCode == Canvas.UP) {
if (top > 0) {
return -top;
} else {
return Item.OUTOFITEM;
}
}
if (gameKeyCode == Canvas.DOWN) {
if (getHeight() > bottom) {
return getHeight() - bottom;
} else {
return Item.OUTOFITEM;
}
}
return 0;
}
// override some methods to disallow modification
// when inside an Alert
public void setPreferredSize(int w, int h) {
Screen owner = this.getOwner();
if (owner != null && owner instanceof Alert)
return;
else
super.setPreferredSize(w, h);
}
public void setLayout(int layout) {
if (owner != null && owner instanceof Alert)
return;
else
super.setLayout(layout);
}
public void setLabel(String label) {
if (owner != null && owner instanceof Alert)
return;
else
super.setLabel(label);
}
public void addCommand(Command cmd) {
if (owner != null && owner instanceof Alert)
return;
else
super.addCommand(cmd);
}
public void setDefaultCommand(Command cmd) {
if (owner != null && owner instanceof Alert)
return;
else
super.setDefaultCommand(cmd);
}
public void setItemCommandListener(ItemCommandListener l) {
if (owner != null && owner instanceof Alert)
return;
else
super.setItemCommandListener(l);
}
}
