* Description:

public abstract class CustomItem extends Item

{

    private boolean repaintPending;

    private int repaintX1;

    private int repaintY1;

    private int repaintX2;

    private int repaintY2;

    private Object repaintLock;

    boolean bufferFlush;

    CustomItemLayouter layouter;

    protected CustomItem(String label)

    {

        repaintLock = new Object();

        cleanupLock = new Object();

        resizeLock = new Object();

    public int getGameAction(int keyCode)

    {

    protected final int getInteractionModes()

    {

               | KEY_PRESS | KEY_RELEASE

               | POINTER_PRESS | POINTER_DRAG | POINTER_RELEASE;

    protected final void invalidate()

    {

    protected final void repaint()

    {

    protected final void repaint(int aX, int aY, int aWidth, int aHeight)

    {

                               int viewportHeight, int[] visRect)

    {

    protected void traverseOut()

    {

    protected void keyPressed(int aKeyCode)

    {

    protected void keyReleased(int aKeyCode)

    {

    protected void keyRepeated(int aKeyCode)

    {

    protected void pointerPressed(int aX, int aY)

    {

    protected void pointerReleased(int aX, int aY)

    {

    protected void pointerDragged(int aX, int aY)

    {

    protected void showNotify()

    {

    protected void hideNotify()

    {

    protected void sizeChanged(int aWidth, int aHeight)

    {

    Point calculateMinimumSize()

    {

    Point calculatePreferredSize()

    {

    void internalHandleSizeChanged(int newWidth, int newHeight)

    {

        if(contentWidth != newWidth || contentHeight != newHeight)

        {

            synchronized(resizeLock)

            {

                contentWidth = newWidth;

                contentHeight = newHeight;

            }

            EventDispatcher eventDispatcher = EventDispatcher.instance();

            LCDUIEvent event = eventDispatcher.newEvent(LCDUIEvent.CUSTOMITEM_SIZECHANGED, layouter.dfi.getForm());

            event.item = this;

            eventDispatcher.postEvent(event);

            synchronized(cleanupLock)

            {

                cleanupNeeded = true;

    /*

     * Note that if you call this and getContentHeight() from a non-UI thread

     * then it must be made sure size doesn't change between the calls.

     */

    int getContentWidth()

    {

    /*

     * Note that if you call this and getContentHeight() from a non-UI thread

     * then it must be made sure size doesn't change between the calls.

     */

    int getContentHeight()

    {

    boolean isFocusable()

    {

     * This gets called when Form contents are modified.

    void setParent(Screen parent)

    {

        if(parent == null)

        {

            // Item was removed from a Form

            layouter = null;

        }

        else

        {

            // Item was added to a Form

            layouter = ((CustomItemLayouter)((Form)parent).getLayoutPolicy().getLayouter(this));

    private boolean invalidate(int x, int y, int width, int height)

    {

        // Regularize bounds

        final int x1 = x;

        final int y1 = y;

        final int x2 = x + width;

        final int y2 = y + height;

        // Union the current and new damaged rects

        final boolean valid = ((repaintX2 - repaintX1) <= 0) && ((repaintY2 - repaintY1) <= 0);

        if(!valid)

        {

            repaintX1 = Math.min(repaintX1, x1);

            repaintY1 = Math.min(repaintY1, y1);

            repaintX2 = Math.max(repaintX2, x2);

            repaintY2 = Math.max(repaintY2, y2);

        }

        else

        {

            repaintX1 = x1;

            repaintY1 = y1;

            repaintX2 = x2;

            repaintY2 = y2;

        }

        // UI thread can change the size at any time. Must make sure it doesn't

        // change between reading the width and the height.

        final int w;

        final int h;

        synchronized(resizeLock)

        {

            w = contentWidth;

            h = contentHeight;

        }

        // Clip to bounds

        repaintX1 = repaintX1 > 0 ? repaintX1 : 0;

        repaintY1 = repaintY1 > 0 ? repaintY1 : 0;

        repaintX2 = repaintX2 < w ? repaintX2 : w;

        repaintY2 = repaintY2 < h ? repaintY2 : h;

        return valid;

    }

    /*

     * Note the control passed as a parameter can change. It must not be stored

     * to the CustomItem. Adding and removing Form item is blocked for the

     * duration of the call.

     */

    void updateItem(Rectangle rect, Control control)

    {

        // Paint callback event is posted without any invalid area info.

        // Invalid area info is kept in the member variables. Only one event

        // per Canvas is added to the queue. If there are more repaint() calls

        // before the already posted event has been served those are merged

        // to the invalid area in the member variables without posting a new

        // event.

        synchronized(repaintLock)

        {

            if(invalidate(rect.x, rect.y, rect.width, rect.height))

            {

                // Note that repaintPending doesn't mean that there's a repaint

                // event in the queue. It means that the invalid area is going

                // to be repainted and there's no need to add a new event.

                // It's possible that the repaint event has already been

                // removed from the queue but repaintPending is still true. In

                // that case it's currently being processed and we can still

                // add to the invalid area.

                if(!repaintPending)

                {

                    EventDispatcher eventDispatcher = EventDispatcher.instance();

                    LCDUIEvent event = eventDispatcher.newEvent(

                                           LCDUIEvent.CUSTOMITEM_PAINT_MIDLET_REQUEST, layouter.dfi.getForm());

                    event.widget = control;

                    event.item = this;

                    eventDispatcher.postEvent(event);

                    repaintPending = true;

                }

            }

        }

    }

     * been removed from the Form.

     */

    void doCallback(final LCDUIEvent event)

    {

        switch(event.type)

        {

        case LCDUIEvent.CUSTOMITEM_PAINT_MIDLET_REQUEST:

        case LCDUIEvent.CUSTOMITEM_PAINT_NATIVE_REQUEST:

            doPaintCallback(event);

            break;

        case LCDUIEvent.CUSTOMITEM_HIDENOTIFY:

            hideNotify();

            break;

        case LCDUIEvent.CUSTOMITEM_SHOWNOTIFY:

            showNotify();

            break;

        case LCDUIEvent.CUSTOMITEM_KEYPRESSED:

            keyPressed(event.keyCode);

            break;

        case LCDUIEvent.CUSTOMITEM_KEYREPEATED:

            keyRepeated(event.keyCode);

            break;

        case LCDUIEvent.CUSTOMITEM_KEYRELEASED:

            keyReleased(event.keyCode);

            break;

        case LCDUIEvent.CUSTOMITEM_POINTERDRAGGED:

            pointerDragged(event.x, event.y);

            break;

        case LCDUIEvent.CUSTOMITEM_POINTERPRESSED:

            pointerPressed(event.x, event.y);

            break;

        case LCDUIEvent.CUSTOMITEM_POINTERRELEASED:

            pointerReleased(event.x, event.y);

            break;

        case LCDUIEvent.CUSTOMITEM_SIZECHANGED:

            sizeChanged(event.width, event.height);

            break;

        default:

            super.doCallback(event);

        }

    }

    /*

     * Dispatcher thread calls.

    void doPaintCallback(final LCDUIEvent event)

    {

        // Decide the area going to be painted by the callback.

        final int redrawNowX;

        final int redrawNowY;

        final int redrawNowW;

        final int redrawNowH;

        // Before this thread obtains the repaintLock any repaint() calls

        // will still be adding to the invalid area that is going to be

        // painted by this callback.

        synchronized(repaintLock)

        {

            if(event.type == LCDUIEvent.CUSTOMITEM_PAINT_NATIVE_REQUEST)

            {

                // Merge with possibly existing repaint() requests

                invalidate(event.x, event.y, event.width, event.height);

            }

            else

            {

                // Need to add a new event to the queue in subsequent repaint()

                // calls.

                repaintPending = false;

            }

            // Store the current area to be painted

            redrawNowX = repaintX1;

            redrawNowY = repaintY1;

            redrawNowW = repaintX2-repaintX1;

            redrawNowH = repaintY2-repaintY1;

            // After releasing the lock the repaint() calls will start with

            // new invalid area.

            repaintX1 = repaintX2 = repaintY1 = repaintY2 = 0;

            // Don't do the callback if there's nothing to paint

            if(!((redrawNowW > 0) && (redrawNowH > 0)))

            {

                return;

            }