scrollbar.java

Java编写的GUI聊天工具

                int k1 = size().height - (Scroller.height + BsizeY);
                Scroller.y = k1;
            }
        }
        repaint();
    }

    void start(Event event)
    {
        lastMouseDown = event;
        if(!running && runner == null)
        {
            runner = new Thread(this);
            running = true;
            runner.start();
        }
    }

    public void enable()
    {
        super.enable();
        calcValues();
        Disabled = false;
        if(Graph != null)
        {
            Graph.dispose();
            Graph = null;
        }
        setScrollPos(1);
        doLineDown();
        doLineUp();
        repaint();
    }

    public void drawScrollBar(Graphics g, int i, int j, int k, int l)
    {
        g.setColor(Colors[0]);
        g.fillRect(i, j, k, l);
        if(Type == 1)
        {
            int k1 = BsizeX;
            int i1 = size().width - (Scroller.width + BsizeX);
            if(Scroller.x < k1)
                Scroller.x = k1;
            if(Scroller.x > i1)
                Scroller.x = i1;
        } else
        {
            int l1 = BsizeY;
            int j1 = size().height - (Scroller.height + BsizeY);
            if(Scroller.y < l1)
                Scroller.y = l1;
            if(Scroller.y > j1)
                Scroller.y = j1;
        }
        if(Type == 1)
        {
            if(Down1)
                drawDownScroller(g, i, j, BsizeX, BsizeY);
            else
                drawScroller(g, i, j, BsizeX, BsizeY);
            drawArrow(g, 1, i + 3, j + 3, BsizeX - 6, BsizeY - 6);
            int i2 = (i + k) - BsizeX;
            if(Down2)
                drawDownScroller(g, i2, j, BsizeX, BsizeY);
            else
                drawScroller(g, i2, j, BsizeX, BsizeY);
            drawArrow(g, 2, i2 + 3, j + 3, BsizeX - 6, BsizeY - 6);
        } else
        {
            if(Down1)
                drawDownScroller(g, i, j, BsizeX, BsizeY);
            else
                drawScroller(g, i, j, BsizeX, BsizeY);
            drawArrow(g, 3, i + 3, j + 3, BsizeX - 6, BsizeY - 6);
            int j2 = (j + l) - BsizeY;
            if(Down2)
                drawDownScroller(g, i, j2, BsizeX, BsizeY);
            else
                drawScroller(g, i, j2, BsizeX, BsizeY);
            drawArrow(g, 4, i + 4, j2 + 4, BsizeX - 7, BsizeY - 7);
        }
        Down1 = Down2 = false;
        if(!Disabled)
            drawScroller(g, Scroller.x, Scroller.y, Scroller.width, Scroller.height);
    }

    void doLineDown()
    {
        int i = TotalArea - ViewArea;
        if(ScrollValue >= i)
            return;
        Down = true;
        Down2 = true;
        ScrollValue += LineValue;
        if(ScrollValue > i)
            ScrollValue = i;
        if(Type == 1)
        {
            int j = size().width - 2 * BsizeX;
            int l = (LineValue * j) / TotalArea;
            if(l <= 0)
                l = 1;
            int j1 = size().width - (Scroller.width + BsizeX);
            Scroller.x += l;
            if(Scroller.x > j1)
                Scroller.x = j1;
            GetHorValue();
        } else
        {
            int k = size().height - 2 * BsizeY;
            int i1 = (LineValue * k) / TotalArea;
            if(i1 <= 0)
                i1 = 1;
            int k1 = size().height - (Scroller.height + BsizeY);
            Scroller.y += i1;
            if(Scroller.y > k1)
                Scroller.y = k1;
            GetVerValue();
        }
        repaint();
        if(ScrollValue != LastValue)
        {
            Event event = new Event(this, 0L, 1001, 0, 0, ScrollValue, 2, null);
            Parent.deliverEvent(event);
            LastValue = ScrollValue;
        }
    }

    public Dimension preferredSize()
    {
        return minimumSize();
    }

    public void drawScroller(Graphics g, int i, int j, int k, int l)
    {
        g.setColor(Colors[4]);
        g.fillRect(i, j, k, l);
        g.setColor(Colors[0]);
        g.drawLine(i, j, (i + k) - 1, j);
        g.drawLine(i, j, i, (j + l) - 1);
        g.setColor(Colors[2]);
        g.drawLine(i + 1, j + 1, (i + k) - 4, j + 1);
        g.drawLine(i + 1, j + 1, i + 1, (j + l) - 4);
        g.setColor(Colors[3]);
        g.drawLine((i + k) - 2, j + 1, (i + k) - 2, (j + l) - 2);
        g.drawLine(i + 1, (j + l) - 2, (i + k) - 2, (j + l) - 2);
        g.setColor(Colors[1]);
        g.drawLine((i + k) - 1, j, (i + k) - 1, (j + l) - 1);
        g.drawLine(i, (j + l) - 1, (i + k) - 1, (j + l) - 1);
    }

    public boolean mouseDown(Event event, int i, int j)
    {
        if(Disabled)
            return true;
        if(Type == 1)
        {
            if(i >= 0 && i <= BsizeX)
            {
                doLineUp();
                start(event);
            } else
            if(i >= size().width - BsizeX && i <= size().width)
            {
                doLineDown();
                start(event);
            } else
            if(i < Scroller.x)
            {
                doPageUp();
                start(event);
            } else
            if(i > Scroller.x + Scroller.width)
            {
                doPageDown();
                start(event);
            }
        } else
        if(j >= 0 && j <= BsizeY)
        {
            doLineUp();
            start(event);
        } else
        if(j >= size().height - BsizeY && j <= size().height)
        {
            doLineDown();
            start(event);
        } else
        if(j < Scroller.y)
        {
            doPageUp();
            start(event);
        } else
        if(j > Scroller.y + Scroller.height)
        {
            doPageDown();
            start(event);
        }
        return true;
    }

    public void run()
    {
        do
        {
            try
            {
                Thread.sleep(sleeptime);
            }
            catch(Exception _ex) { }
            postEvent(lastMouseDown);
            repaint();
        } while(true);
    }

    public void setScrollValue(int i, int j, int k)
    {
        int l = TotalArea - ViewArea;
        if(i < 0 || i > l)
            ScrollValue = 0;
        else
            ScrollValue = i;
        PageValue = j;
        LineValue = k;
        repaint();
    }

    public boolean mouseDrag(Event event, int i, int j)
    {
        if(Disabled || Down)
            return true;
        if(Type == 1)
        {
            Scroller.x += i - LastX;
            int k = size().width - (Scroller.width + BsizeX);
            int i1 = BsizeX;
            if(Scroller.x + Scroller.width > size().width - BsizeX)
                Scroller.x = k;
            if(Scroller.x < i1)
                Scroller.x = i1;
            GetHorValue();
        } else
        {
            Scroller.y += j - LastY;
            int l = size().height - (Scroller.height + BsizeY);
            int j1 = BsizeY;
            if(Scroller.y + Scroller.height > size().height - BsizeY)
                Scroller.y = l;
            if(Scroller.y < j1)
                Scroller.y = j1;
            GetVerValue();
        }
        LastX = i;
        LastY = j;
        repaint();
        if(ScrollValue != LastValue)
        {
            Event event1 = new Event(this, 0L, 1001, 0, 0, ScrollValue, 5, null);
            Parent.deliverEvent(event1);
            LastValue = ScrollValue;
        }
        return true;
    }

    void doPageDown()
    {
        Down = true;
        Graphics g = getGraphics();
        g.setColor(Colors[3]);
        ScrollValue += PageValue;
        int i = TotalArea - ViewArea;
        if(ScrollValue > i)
            ScrollValue = i;
        if(Type == 1)
        {
            int j = size().width - 2 * BsizeX;
            int l = (PageValue * j) / TotalArea;
            int j1 = Scroller.x + Scroller.width;
            g.fillRect(j1, 0, size().width - j1 - BsizeX, size().height - 1);
            Scroller.x += l;
            int l1 = size().width - (Scroller.width + BsizeX);
            if(Scroller.x > l1)
                Scroller.x = l1;
        } else
        {
            int k = size().height - 2 * BsizeY;
            int i1 = (PageValue * k) / TotalArea;
            int k1 = Scroller.y + Scroller.height;
            g.fillRect(0, k1, size().width - 1, size().height - k1 - BsizeY);
            Scroller.y += i1;
            int i2 = size().height - (Scroller.height + BsizeY);
            if(Scroller.y > i2)
                Scroller.y = i2;
        }
        Event event = new Event(this, 0L, 1001, 0, 0, ScrollValue, 4, null);
        Parent.deliverEvent(event);
        g.dispose();
    }

    public final int HORIZONTAL = 1;
    public final int VERTICAL = 2;
    public final int MINPOS = 1;
    public final int MAXPOS = 2;
    Color Colors[];
    Component Parent;
    int Xpnt[];
    int Ypnt[];
    Rectangle Scroller;
    Dimension Dim;
    Graphics Graph;
    Image Img;
    boolean Down;
    boolean Down1;
    boolean Down2;
    int Dwidth;
    int Dheight;
    int LastValue;
    int LastX;
    int LastY;
    int BsizeX;
    int BsizeY;
    int Width;
    int Height;
    int Type;
    public boolean Disabled;
    public int ScrollValue;
    public int TotalArea;
    public int ViewArea;
    public int PageValue;
    public int LineValue;
    boolean running;
    Thread runner;
    Event lastMouseDown;
    int sleeptime;
}