/*

 * Copyright 2003-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

// Very much based on XListPeer from javaos

package sun.awt.X11;

import java.awt.*;

import java.awt.event.*;

import java.awt.peer.*;

import java.util.Vector;

import java.awt.geom.*;

import java.awt.image.*;

// TODO: some input actions should do nothing if Shift or Control are down

class XListPeer extends XComponentPeer implements ListPeer, XScrollbarClient {

    public final static int     MARGIN = 2;

    public final static int     SPACE = 1;

    public final static int     SCROLLBAR_AREA = 17;  // Area reserved for the

                                                      // scrollbar

    public final static int     SCROLLBAR_WIDTH = 13; // Actual width of the

                                                      // scrollbar

    public final static int     NONE = -1;

    public final static int     WINDOW = 0;

    public final static int     VERSCROLLBAR = 1;

    public final static int     HORSCROLLBAR = 2;

    public final static int     DEFAULT_VISIBLE_ROWS = 4; // From java.awt.List,

    public final static int     HORIZ_SCROLL_AMT = 10;

    private final static int    PAINT_VSCROLL = 2;

    private final static int    PAINT_HSCROLL = 4;

    private final static int    PAINT_ITEMS = 8;

    private final static int    PAINT_FOCUS = 16;

    private final static int    PAINT_BACKGROUND = 32;

    private final static int    PAINT_HIDEFOCUS = 64;

    private final static int    PAINT_ALL =

        PAINT_VSCROLL | PAINT_HSCROLL | PAINT_ITEMS | PAINT_FOCUS | PAINT_BACKGROUND;

    private final static int    COPY_AREA = 128;

    XVerticalScrollbar       vsb;

    XHorizontalScrollbar     hsb;

    ListPainter painter;

    // TODO: ick - Vector?

    Vector                      items;

    boolean                     multipleSelections;

    int                         active = NONE;

    // Holds the array of the indexes of the elements which is selected

    // This array should be kept sorted, low to high.

    int                         selected[];

    int                         fontHeight;

    int                         fontAscent;

    int                         fontLeading;

    // Holds the index of the item used in the previous operation (selectItem, deselectItem)

    // Adding of an item or clearing of the list sets this index to -1

    // The index is used at the moment of the post of ACTION_PERFORMED event after the mouse double click event.

    int                         currentIndex = -1;

    // Used for tracking selection/deselection between mousePress/Release

    // and for ItemEvents

    int                         eventIndex = -1;

    int                         eventType = NONE;

    // Holds the index of the item that receive focus

    // This variable is reasonable only for multiple list

    // since 'focusIndex' and 'selected[0]' are equal for single-selection list

    int                         focusIndex;

    int                         maxLength;

    boolean                     vsbVis;  // visibility of scrollbars

    boolean                     hsbVis;

    int                         listWidth;  // Width of list portion of List

    int                         listHeight; // Height of list portion of List

    // (i.e. without scrollbars)

    private int firstTimeVisibleIndex = 0;

    // Motif Lists don't seem to inherit the background color from their

    // parent when an app is first started up.  So, we track if the colors have

    // been set.  See getListBackground()/getListForeground().

    boolean bgColorSet;

    boolean fgColorSet;

    // Holds the true if mouse is dragging outside of the area of the list

    // The flag is used at the moment of the dragging and releasing mouse

    // See 6243382 for more information

    boolean mouseDraggedOutHorizontally = false;

    boolean mouseDraggedOutVertically = false;

    // Holds the true if a mouse event was originated on the scrollbar

    // See 6300527 for more information

    boolean isScrollBarOriginated = false;

    // This variable is set to true after the "mouse pressed" event and to false after the "mouse released" event

    // Fixed 6293432: Key events ('SPACE', 'UP', 'DOWN') aren't blocked if mouse is kept in 'PRESSED' state for List, XAWT

    boolean isMousePressed = false;

    /**

     * Create a list

     */

    XListPeer(List target) {

        super(target);

    }

    /**

     * Overridden from XWindow

     */

    public void preInit(XCreateWindowParams params) {

        super.preInit(params);

        // Stuff that must be initialized before layout() is called

        items = new Vector();

        createVerScrollbar();

        createHorScrollbar();

        painter = new ListPainter();

        // See 6246467 for more information

        bgColorSet = target.isBackgroundSet();

        fgColorSet = target.isForegroundSet();

    }

    public void postInit(XCreateWindowParams params) {

        super.postInit(params);

        initFontMetrics();

        // TODO: more efficient way?

        //       do we really want/need a copy of all the items?

        // get all items from target

        List l = (List)target;

        int stop = l.getItemCount();

        for (int i = 0 ; i < stop; i++) {

            items.addElement(l.getItem(i));

        }

        /* make the visible position visible. */

        int index = l.getVisibleIndex();

        if (index >= 0) {

            // Can't call makeVisible since it check scroll bar,

            // initialize scroll bar instead

            vsb.setValues(index, 0, 0, items.size());

        }

        // NOTE: needs to have target set

        maxLength = maxLength();

        // get the index containing all indexes to selected items

        int sel[] = l.getSelectedIndexes();

        selected = new int[sel.length];

        // TODO: shouldn't this be arraycopy()?

        for (int i = 0 ; i < sel.length ; i ++) {

            selected[i] = sel[i];

        }

        // The select()ed item should become the focused item, but we don't

        // get the select() call because the peer generally hasn't yet been

        // created during app initialization.

        // TODO: For multi-select lists, it should be the highest selected index

        if (sel.length > 0) {

            setFocusIndex(sel[sel.length - 1]);

        }

        else {

            setFocusIndex(0);

        }

        multipleSelections = l.isMultipleMode();

    }

    /**

     * add Vertical Scrollbar

     */

    void createVerScrollbar() {

        vsb = new XVerticalScrollbar(this);

        vsb.setValues(0, 0, 0, 0, 1, 1);

    }

    /**

     * add Horizontal scrollbar

     */

    void createHorScrollbar() {

        hsb = new XHorizontalScrollbar(this);

        hsb.setValues(0, 0, 0, 0, HORIZ_SCROLL_AMT, HORIZ_SCROLL_AMT);

    }

    /* New method name for 1.1 */

    public void add(String item, int index) {

        addItem(item, index);

    }

    /* New method name for 1.1 */

    public void removeAll() {

        clear();

        maxLength = 0;

    }

    /* New method name for 1.1 */

    public void setMultipleMode (boolean b) {

        setMultipleSelections(b);

    }

    /* New method name for 1.1 */

    public Dimension getPreferredSize(int rows) {

        return preferredSize(rows);

    }

    /* New method name for 1.1 */

    public Dimension getMinimumSize(int rows) {

        return minimumSize(rows);

    }

    /**

     * Minimum size.

     */

    public Dimension minimumSize() {

        return minimumSize(DEFAULT_VISIBLE_ROWS);

    }

    /**

     * return the preferredSize

     */

    public Dimension preferredSize(int v) {

        return minimumSize(v);

    }

    /**

     * return the minimumsize

     */

    public Dimension minimumSize(int v) {

        FontMetrics fm = getFontMetrics(getFont());

        initFontMetrics();

        return new Dimension(20 + fm.stringWidth("0123456789abcde"),

                             getItemHeight() * v + (2*MARGIN));

    }

    /**

     * Calculate font metrics

     */

    void initFontMetrics() {

        FontMetrics fm = getFontMetrics(getFont());

        fontHeight = fm.getHeight();

        fontAscent = fm.getAscent();

        fontLeading = fm.getLeading();

    }

    /**

     * return the length of the largest item in the list

     */

    int maxLength() {

        FontMetrics fm = getFontMetrics(getFont());

        int m = 0;

        int end = items.size();

        for(int i = 0 ; i < end ; i++) {

            int l = fm.stringWidth(((String)items.elementAt(i)));

            m = Math.max(m, l);

        }

        return m;

    }

    /**

     * Calculates the width of item's label

     */

    int getItemWidth(int i) {

        FontMetrics fm = getFontMetrics(getFont());

        return fm.stringWidth((String)items.elementAt(i));

    }

    /**

     * return the on-screen width of the given string "str"

     */

    int stringLength(String str) {

        FontMetrics fm = getFontMetrics(target.getFont());

        return fm.stringWidth(str);

    }

    public void setForeground(Color c) {

        fgColorSet = true;

        super.setForeground(c);

    }

    public void setBackground(Color c) {

        bgColorSet = true;

        super.setBackground(c);

    }

    /**

     * Returns the color that should be used to paint the background of

     * the list of items.  Note that this is not the same as

     * target.getBackground() which is the color of the scrollbars, and the

     * lower-right corner of the Component when the scrollbars are displayed.

     */

    private Color getListBackground(Color[] colors) {

        if (bgColorSet) {

            return colors[BACKGROUND_COLOR];

        }

        else {

            return SystemColor.text;

        }

    }

    /**

     * Returns the color that should be used to paint the list item text.

     */

    private Color getListForeground(Color[] colors) {

        if (fgColorSet) {

            return colors[FOREGROUND_COLOR];

        }

        else {

            return SystemColor.textText;

        }

    }

    Rectangle getVScrollBarRec() {

        return new Rectangle(width - (SCROLLBAR_WIDTH), 0, SCROLLBAR_WIDTH+1, height);

    }

    Rectangle getHScrollBarRec() {

        return new Rectangle(0, height - SCROLLBAR_WIDTH, width, SCROLLBAR_WIDTH);

    }

    int getFirstVisibleItem() {

        if (vsbVis) {

            return vsb.getValue();

        } else {

            return 0;

        }

    }

    int getLastVisibleItem() {

        if (vsbVis) {

            return Math.min(items.size()-1, vsb.getValue() + itemsInWindow() -1);

        } else {

            return Math.min(items.size()-1, itemsInWindow()-1);

        }

    }

    public void repaintScrollbarRequest(XScrollbar scrollbar) {

        Graphics g = getGraphics();

        if (scrollbar == hsb)  {

            repaint(PAINT_HSCROLL);

        }

        else if (scrollbar == vsb) {

            repaint(PAINT_VSCROLL);

        }

    }

    /**

     * Overridden for performance

     */

    public void repaint() {

        repaint(getFirstVisibleItem(), getLastVisibleItem(), PAINT_ALL);

    }

    private void repaint(int options) {

        repaint(getFirstVisibleItem(), getLastVisibleItem(), options);

    }

    private void repaint(int firstItem, int lastItem, int options) {

        repaint(firstItem, lastItem, options, null, null);

    }

    /**

     * In most cases the entire area of the component doesn't have

     * to be repainted. The method repaints the particular areas of

     * the component. The areas to repaint is specified by the option

     * parameter. The possible values of the option parameter are:

     * PAINT_VSCROLL, PAINT_HSCROLL, PAINT_ITEMS, PAINT_FOCUS,

     * PAINT_HIDEFOCUS, PAINT_BACKGROUND, PAINT_ALL, COPY_AREA.

     *

     * Note that the COPY_AREA value initiates copy of a source area

     * of the component by a distance by means of the copyArea method

     * of the Graphics class.

     *

     * @param firstItem the position of the first item of the range to repaint

     * @param lastItem the position of the last item of the range to repaint

     * @param options specifies the particular area of the component to repaint

     * @param source the area of the component to copy

     * @param distance the distance to copy the source area

     */

    private void repaint(int firstItem, int lastItem, int options, Rectangle source, Point distance) {

        Graphics g = getGraphics();

        try {

            painter.paint(g, firstItem, lastItem, options, source, distance);

        } finally {

            g.dispose();

        }

    }

    public void paint(Graphics g) {

        painter.paint(g, getFirstVisibleItem(), getLastVisibleItem(), PAINT_ALL);

    }

    public boolean isFocusable() { return true; }

    // TODO: share/promote the Focus methods?

    public void focusGained(FocusEvent e) {

        super.focusGained(e);

        repaint(PAINT_FOCUS);

    }

    public void focusLost(FocusEvent e) {

        super.focusLost(e);

        repaint(PAINT_FOCUS);

    }

    /**

     * Layout the sub-components of the List - that is, the scrollbars and the

     * list of items.

     */

    public void layout() {

        int vis, maximum;

        boolean vsbWasVisible;

        int origVSBVal;

        assert(target != null);

        // Start with assumption there is not a horizontal scrollbar,

        // see if we need a vertical scrollbar

        // Bug: If the list DOES have a horiz scrollbar and the value is set to

        // the very bottom value, value is reset in setValues() because it isn't

        // a valid value for cases when the list DOESN'T have a horiz scrollbar.

        // This is currently worked-around with origVSGVal.

        origVSBVal = vsb.getValue();

        vis = itemsInWindow(false);

        maximum = items.size() < vis ? vis : items.size();

        vsb.setValues(vsb.getValue(), vis, vsb.getMinimum(), maximum);

        vsbVis = vsbWasVisible = vsbIsVisible(false);

        listHeight = height;

        // now see if we need a horizontal scrollbar

        listWidth = getListWidth();

        vis = listWidth - ((2 * SPACE) + (2 * MARGIN));

        maximum = maxLength < vis ? vis : maxLength;

        hsb.setValues(hsb.getValue(), vis, hsb.getMinimum(), maximum);

        hsbVis = hsbIsVisible(vsbVis);

        if (hsbVis) {

            // do need a horizontal scrollbar, so recalculate height of

            // vertical s crollbar

            listHeight = height - SCROLLBAR_AREA;

            vis = itemsInWindow(true);

            maximum = items.size() < vis ? vis : items.size();

            vsb.setValues(origVSBVal, vis, vsb.getMinimum(), maximum);

            vsbVis = vsbIsVisible(true);

        }

        // now check to make sure we haven't changed need for vertical

        // scrollbar - if we have, we need to

        // recalculate horizontal scrollbar width - then we're done...

        if (vsbWasVisible != vsbVis) {

            listWidth = getListWidth();

            vis = listWidth - ((2 * SPACE) + (2 * MARGIN));

            maximum = maxLength < vis ? 0 : maxLength;

            hsb.setValues(hsb.getValue(), vis, hsb.getMinimum(), maximum);

            hsbVis = hsbIsVisible(vsbVis);

        }

        vsb.setSize(SCROLLBAR_WIDTH, listHeight);

        hsb.setSize(listWidth, SCROLLBAR_WIDTH);

        vsb.setBlockIncrement(itemsInWindow());

        hsb.setBlockIncrement(width - ((2 * SPACE) + (2 * MARGIN) + (vsbVis ? SCROLLBAR_AREA : 0)));

    }

    int getItemWidth() {

        return width - ((2 * MARGIN) + (vsbVis ? SCROLLBAR_AREA : 0));

    }

    /* Returns height of an item in the list */

    int getItemHeight() {

        return (fontHeight - fontLeading) + (2*SPACE);

    }

    int getItemX() {

        return MARGIN + SPACE;

    }

    int getItemY(int item) {

        return index2y(item);

    }

    int getFocusIndex() {

        return focusIndex;

    }

    void setFocusIndex(int value) {

        focusIndex = value;

    }

    /**

     * Update and return the focus rectangle.

     * Focus is around the focused item, if it is visible, or

     * around the border of the list if the focused item is scrolled off the top