gauge.java

有关j2me的很好的例子可以研究一下

        for (int i = startBlock; i < stopBlock; i++) {

            int blockHeight;
            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);
            } else {
                blockHeight = GAUGE_HEIGHT;
            }

            if ((valueOfEachBlock * (i + 1)) > value && value != maxValue)
            {
                if (hasFocus()) {
                    g.drawRect((i * BLOCK_SPACE) + 6, 
                               GAUGE_HEIGHT - blockHeight,
                               BLOCK_SPACE - 3, blockHeight);
                } else {
                    g.setStrokeStyle(Graphics.DOTTED);

                    g.drawRect((i * BLOCK_SPACE) + 6, 
                               GAUGE_HEIGHT - blockHeight,
                               BLOCK_SPACE - 3, blockHeight);
                    g.setStrokeStyle(Graphics.SOLID);
                }
            } else {
                g.fillRect((i * BLOCK_SPACE) + 6, 
                           GAUGE_HEIGHT - blockHeight,
                           BLOCK_SPACE - 3, blockHeight);
            }
        }

        g.translate(0, -layoutHeight);

        setHorizontalScroll();
    }

    /**
     * Signal this Gauge that its focus has changed
     * (either gained or lost focus)
     */
    void focusChanged() {
        if (!hasFocus()) {
            // We have lost the focus, so we need to re-set
            // the right/left arrows, as the next component
            // to receive focus may not use the left/right
            // arrows at all, and Screen no longer re-sets
            // the horizontal arrows for us
            getOwner().setHorizontalScroll(0, 100);
        }
        super.focusChanged();
    }

    /**
     * Set the width for this Guage
     *
     * @param width The width to set this Gauge to
     * @return int The height required to display this Gauge in the
     *              given width
     */
    int setWidth(int width) {
        height = GAUGE_HEIGHT + 5;
        height += layouts[0].setWidth(width);
        return height;
    }

    /**
     * Get the height of this Gauge
     *
     * @return int The height of this Gauge
     */
    int getHeight() {
        return height;
    }

    /**
     * Handle a key press
     *
     * @param keyCode The key that was pressed
     * @return boolean A flag indicating the key pressed was handled
     *                  by this Gauge
     */
    boolean keyPressed(int keyCode) {
        if (!interactive) {
            return false;
        }

        if ((Display.getGameAction(keyCode) ==  Canvas.LEFT) ||
            (Display.getGameAction(keyCode) ==  Canvas.RIGHT))
        {

            // 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 (Display.getGameAction(keyCode) == 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();

            // There's no need to cause a repaint if none of the
            // blocks either need to be filled in or need to be
            // un-filled.
            if (blockToRepaint < 0 || blockToRepaint >= blockCount) {
                setHorizontalScroll();
                return value != oldValue;
            }

            // We need to remember to offset by the height of our
            // label if there is one.
            int blockY = 0;
            blockY = layouts[0].getHeight();

            // Cause a repaint of only the bar which needs updating
            repaint(blockToRepaint * BLOCK_SPACE + 6, blockY,
                    BLOCK_SPACE - 2, GAUGE_HEIGHT + 2);

            return value != oldValue;
        }
        return false;
    }

    // private implementation

    /**
     * Set the number of blocks rendered by this Gauge. This
     * will use the width of the display and calculate the
     * blockCount value.
     */
    private void setBlockCount() {
        this.blockCount = (Display.WIDTH - 8) / BLOCK_SPACE;
        if (blockCount > maxValue) {
            blockCount = maxValue;
        }
    }

    /**
     * Set the value of each block. This will use the
     * blockCount value and maxValue to assign a value
     * to each block.
     */
    private void setBlockValue() {
        valueOfEachBlock = 1;

        if (maxValue <= blockCount) {
            return;
        }

        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.
    }

    /**
     * Set the horizontal "scroll" for this Gauge. Note that
     * "scroll" is a bit of a misnomer, but we are turning on
     * the left/right indicator arrows on the display to signal
     * the user the Gauge can be incremented/decremented.
     */
    private void setHorizontalScroll() {
            // If we have focus and are interactive, we check
            // to see if we need to add the right or left arrow
            if (hasFocus() && interactive) {
                // NOTE: I couldn't think offhand how to do an
                // accurate proportion value, so I just use 50
                int scrollPosition = value * 100 / maxValue;
                // Fix the rounding error
                if (value > 0 && scrollPosition == 0) {
                    scrollPosition = 1;
            }
                getOwner().setHorizontalScroll(scrollPosition, (50));
            }
    }

    /**
     * Utility method to ensure the value of the Gauge is always
     * in a range of 0 to maxValue
     *
     * @return int The corrected version of the current value
     */
    private int checkValue() {
        if (value < 0) {
            value = 0;
        } else if (value > maxValue) {
            value = maxValue;
        }
        return value;
    }

    /**
     * Set the max value of this Gauge
     *
     * @param maxValue The maximum value to set for this Gauge
     */
    private void setMaxValueImpl(int maxValue) {
        if (maxValue <= 0) {
            throw new IllegalArgumentException();
        }

        this.maxValue = maxValue;
        checkValue();

        // If the max value changes, the block count needs
        // to be re-calculated
        setBlockCount();
        setBlockValue();

        contentChanged(0, height - (GAUGE_HEIGHT + 5), 0);
    }
}