componentscreen.java

moto手机专用的LWT类库源码

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   ComponentScreen.java

package com.motorola.lwt;

import javax.microedition.lcdui.*;

// Referenced classes of package com.motorola.lwt:
//            Component

public class ComponentScreen extends Canvas
{

    static final int SCROLLBAR_WIDTH = 18;
    static final int SCROLLBAR_ARROW_HEIGHT = 15;
    static final int SCROLLBAR_THUMB_HEIGHT = 28;
    static Image scrollbarThumb;
    static Image scrollbarArrows;
    int focusOwnerIndex;
    Component components[];
    int componentCount;
    int maxY;
    Component pointerTarget;
    int scrollOffset;
    boolean invalid;
    boolean scrollBarVisible;
    boolean thumbPressed;
    int thumbPressY;
    int currentScreenWidth;
    int thumbOffset;
    int upKey;
    int downKey;

    static Image loadImage(long al[], int i)
    {
        byte abyte0[] = new byte[i];
        int j = 0;
        int k = 0;
        int l = 0;
        long l1 = 0L;
        while(k < i) 
        {
            if(l == 0)
            {
                l1 = al[j++];
                l = 8;
            }
            abyte0[k++] = (byte)(int)(l1 & 255L);
            l1 >>= 8;
            l--;
        }
        try
        {
            return Image.createImage(abyte0, 0, i);
        }
        catch(Throwable throwable)
        {
            return null;
        }
    }

    public void setFocusNext()
    {
        setFocusNext(focusOwnerIndex + 1);
    }

    public void setFocusPrevious()
    {
        if(focusOwnerIndex >= 0)
            setFocusPrevious(focusOwnerIndex - 1);
        else
            setFocusNext(0);
    }

    public void setFocusFirst()
    {
        setFocusNext(0);
    }

    public void setFocusLast()
    {
        setFocusPrevious(componentCount - 1);
    }

    private void setFocusNext(int i)
    {
        int j;
        for(j = i % componentCount; !components[j].acceptsFocus();)
        {
            j = (j + 1) % componentCount;
            if(j == i)
                return;
        }

        setFocusOwner(j);
    }

    private void setFocusPrevious(int i)
    {
        int j;
        for(j = (i + componentCount) % componentCount; !components[j].acceptsFocus();)
        {
            j = ((j + componentCount) - 1) % componentCount;
            if(j == i)
                return;
        }

        setFocusOwner(j);
    }

    synchronized void setFocusOwner(Component component)
    {
        for(int i = componentCount - 1; i >= 0; i--)
            if(component == components[i])
            {
                setFocusOwner(i);
                return;
            }

    }

    synchronized void setFocusOwner(int i)
        throws IndexOutOfBoundsException
    {
        if(i < 0 || i >= componentCount)
            throw new IndexOutOfBoundsException();
        if(i != focusOwnerIndex)
        {
            if(focusOwnerIndex >= 0)
                components[focusOwnerIndex].lostFocus();
            focusOwnerIndex = i;
            components[i].gainedFocus();
            scrollTo(components[i]);
        }
    }

    public synchronized Component getFocusOwner()
    {
        return focusOwnerIndex >= 0 ? components[focusOwnerIndex] : null;
    }

    public void scrollTo(Component component)
    {
        if(component.parent == this)
        {
            int i = component.getHeight();
            int j = getHeight();
            int k = component.getY();
            if(i >= j)
            {
                if(k + i < scrollOffset + j)
                    setScrollOffset((k + i) - j);
                else
                if(k > scrollOffset)
                    setScrollOffset(k);
            } else
            if(k < scrollOffset)
                setScrollOffset(k);
            else
            if(k + i > scrollOffset + j)
                setScrollOffset((k + i) - j);
        }
    }

    public synchronized void setScrollOffset(int i)
    {
        int j = maxY - getHeight();
        if(i > j)
            i = j;
        if(i < 0)
            i = 0;
        scrollOffset = i;
        if(scrollBarVisible)
        {
            int k = getHeight();
            thumbOffset = (scrollOffset * (k - 30 - 28)) / (maxY - k);
            repaint(0, 0, super.getWidth(), getHeight());
        }
        repaint();
    }

    public synchronized int getScrollOffset()
    {
        return scrollOffset;
    }

    public void paint(Graphics g)
    {
        g.setColor(0xffffff);
        g.fillRect(0, 0, getWidth(), getHeight());
        paintComponents(g);
    }

    protected void paintComponents(Graphics g)
    {
        if(componentCount > 0)
        {
            validate();
            int i = g.getClipX();
            int j = g.getClipY() + scrollOffset;
            int k = g.getClipWidth();
            int l = g.getClipHeight();
            int i1 = i + k;
            int j1 = j + l;
            int k1 = g.getTranslateX();
            int l1 = g.getTranslateY();
            for(int i2 = 0; i2 < componentCount; i2++)
            {
                Component component = components[i2];
                if(component.isVisible() && component.getX() < i1 && component.getX() + component.getWidth() > i && component.getY() < j1 && component.getY() + component.getHeight() > j)
                {
                    g.clipRect(component.getX(), component.getY() - scrollOffset, component.getWidth(), component.getHeight());
                    g.translate(component.getX(), component.getY() - scrollOffset);
                    g.setColor(0);
                    g.setStrokeStyle(0);
                    g.setFont(Font.getDefaultFont());
                    try
                    {
                        component.paint(g);
                    }
                    catch(Throwable throwable)
                    {
                        throwable.printStackTrace();
                    }
                    g.translate(k1 - g.getTranslateX(), l1 - g.getTranslateY());
                    g.setClip(i, j - scrollOffset, k, l);
                }
            }

            j -= scrollOffset;
            if(scrollBarVisible)
            {
                int j2 = getHeight();
                int k2 = getWidth();
                g.setColor(0xffffff);
                g.fillRect(k2, 0, 18, j2);
                g.clipRect(k2, 0, 18, 15);
                g.drawImage(scrollbarArrows, k2, 0, 20);
                g.setClip(i, j, k, l);
                g.clipRect(k2, j2 - 15, 18, 15);
                g.drawImage(scrollbarArrows, k2, j2 - 30, 20);
                g.setClip(i, j, k, l);
                g.setColor(0);
                g.drawLine(k2 + 9, 15, k2 + 9, j2 - 15);
                g.clipRect(k2, 15 + thumbOffset, 18, 28);
                g.drawImage(scrollbarThumb, k2, thumbOffset + 15, 20);
            }
        }
    }

    public void invalidate()
    {
        if(!invalid)
        {
            invalid = true;
            repaint(0, 0, super.getWidth(), getHeight());
        }
    }

    public void validate()
    {
        if(invalid)
        {
            currentScreenWidth = super.getWidth() - (scrollBarVisible ? 18 : 0);
            doLayout();
            if(maxY > getHeight())
            {
                if(!scrollBarVisible)
                {
                    scrollBarVisible = true;
                    currentScreenWidth -= 18;
                    doLayout();
                }
            } else
            if(scrollBarVisible)
            {
                scrollBarVisible = false;
                currentScreenWidth += 18;
                doLayout();
            }
            invalid = false;
        }
    }

    public int getWidth()
    {
        return super.getWidth() - (scrollBarVisible ? 18 : 0);
    }

    protected void showNotify()
    {
        invalidate();
        validate();
    }

    protected void doLayout()
    {
        Component component = null;
        maxY = 0;
        for(int i = 1; i < componentCount; i++)
        {
            Component component1 = components[i];
            if(component1.visible)
            {
                int j = component1.leftEdgeValue;
                switch(component1.leftEdgeScheme)
                {
                default:
                    break;

                case 1: // '\001'
                    j += currentScreenWidth >> 1;
                    break;

                case 2: // '\002'
                    j += currentScreenWidth;
                    break;

                case 3: // '\003'
                    if(component != null)
                        j += component.x;
                    break;

                case 4: // '\004'
                    if(component != null)
                        j += component.x + (component.width >> 1);
                    break;

                case 5: // '\005'
                    if(component != null)
                        j += component.x + component.width;
                    break;
                }
                int k = component1.rightEdgeValue;
                switch(component1.rightEdgeScheme)
                {
                default:
                    break;

                case 1: // '\001'
                    k += currentScreenWidth >> 1;
                    break;